Quick answer: build-your-own-x is a free GitHub list, maintained by CodeCrafters, of step-by-step tutorials for rebuilding technologies such as databases, shells, Git and operating systems from scratch. It links to external guides rather than hosting a course. Start with a small project in a language you already know, then move up a level. Most developers use a database, a shell, a version control system or a web framework every day without ever seeing the inside of one. That works until something breaks in a way the documentation does not explain. The build-your-own-x repository exists to close that gap. It collects tutorials that walk you through rebuilding a simplified version of tools you already depend on. The repository is also very large, and it does not tell you where to begin. This guide fills that gap. It explains what the build your own x GitHub repository is, how it differs from CodeCrafters, what is inside it, which project to pick by level and goal, how to judge a tutorial before you invest a weekend, and a method for actually finishing what you start. It is written for self-taught developers, developers who want more depth, and team leads who want practical upskilling ideas. In this guide: What it is | CodeCrafters comparison | Why build from scratch | Category map | Which project first | Choosing a tutorial | Method | Limitations | Teams | Next steps | FAQ
What Is Build Your Own X?
Build Your Own X is a public repository at codecrafters-io/build-your-own-x. Its README describes it as a compilation of well-written, step-by-step guides for re-creating favorite technologies from scratch, and it opens with a line often attributed to Richard Feynman: what I cannot create, I do not understand. The project was started by Daniel Stefanovic and is now maintained by CodeCrafters, Inc., according to the README. It is a curated list, not a course. Each entry follows the same pattern: the programming language in bold, the tutorial title in italics, and a link to a guide hosted somewhere else. Some entries are tagged as video or pdf. The list itself is released under a CC0 waiver, but every linked tutorial keeps its own license, so check before reusing any code. The repository is popular. As of October 27, 2026, GitHub showed about 556,000 stars and 52,100 forks. It is organized into 29 indexed categories plus an Uncategorized section, running from 3D renderers and AI models to web browsers and web servers.
| At a glance | Detail |
|---|---|
| Repository | codecrafters-io/build-your-own-x |
| Maintainer | CodeCrafters, Inc. |
| Format | Curated links to external tutorials, tagged by language |
| License of the list | CC0 waiver (linked tutorials have their own licenses) |
| Size on October 27, 2026 | About 556,000 stars, 52,100 forks, 29 indexed categories plus Uncategorized |
| Cost to read | Free |
Build Your Own X vs CodeCrafters: What Is the Difference?
The two names are easy to confuse. The repository is a free, curated list of tutorials that live on other sites. CodeCrafters is a company that runs a platform where projects are structured as challenges in the same “Build your own X” format, for example Build your own Git, as its own concepts page explains. In the interest of transparency, CodeCrafters, Inc. also maintains the repository. A fair way to think about it is that the repository is the map and a guided platform is one way to walk the route. The free list is enough if you are comfortable picking a tutorial, setting your own checkpoints and judging your own result. A guided platform may suit you if you prefer a structured path with built-in checks. Terms and pricing change, so check the CodeCrafters site for current details rather than relying on a third-party summary.
| Build Your Own X repository | CodeCrafters platform | |
|---|---|---|
| What it is | Curated list of external tutorials | Company platform with project challenges |
| Run by | Community, maintained by CodeCrafters, Inc. | CodeCrafters, Inc. |
| Format | Links, one per tutorial and language | Guided challenges in the Build your own X format |
| Feedback and testing | Depends on each tutorial | Part of the platform design |
| Cost model | Free to browse | Check the CodeCrafters site |
| Best for | Browsing options and choosing freely | Readers who want a structured path |
Why Build From Scratch? What You Actually Learn
Using a tool and understanding it are different skills. Rebuilding a small version forces you to answer questions the API never asks. Four examples from the repository show what that looks like.
- A Redis-style server teaches you how a network server accepts connections, parses a wire protocol and replies. The event loop and the protocol stop being abstract ideas.
- A Git clone shows how content and history can be stored and linked, which makes branching and commits easier to reason about.
- A container build introduces namespaces and process isolation, the Linux features that containers rely on.
- A language build walks you through a lexer, a parser and a syntax tree, the same stages real compilers and interpreters use. The people who benefit most are self-taught developers who want fundamentals, backend developers who want to understand their infrastructure, and candidates preparing for technical interviews. One limit is worth stating plainly. Toy versions skip performance work, security hardening and edge cases, so they build understanding rather than production readiness.
What Is Inside Build Your Own X: The Category Map
The README groups tutorials under 29 indexed categories. They fall into five natural clusters. The entries below were checked against the README on October 27, 2026.
| Cluster | Categories included | Sample entry | Common languages |
|---|---|---|---|
| Systems and infrastructure | Operating System, Processor, Memory Allocator, Network Stack, Emulator or Virtual Machine, Docker | Linux containers in 500 lines of code | C, Rust, Go, Assembly |
| Languages and developer tools | Programming Language, Shell, Regex Engine, Git, Text Editor, Command-Line Tool, Template Engine | Crafting Interpreters | C, Python, Go, Haskell |
| Data, web and front end | Database, Search Engine, Web Server, Web Browser, Front-end Framework | Build Your Own Database from Scratch | Go, C++, Python, JavaScript |
| AI and machine learning | AI Model, Neural Network, Visual Recognition System | LLMs-from-scratch | Python, Go, F# |
| Graphics, games, networking and crypto | 3D Renderer, Game, Physics Engine, Voxel Engine, Augmented Reality, BitTorrent Client, Blockchain, Bot | Ray Tracing in One Weekend | C++, JavaScript, Go |
Systems and infrastructure
This cluster is for readers who want to see how computers and runtimes work underneath. The README lists a Linux containers tutorial in about 500 lines of C and a container-in-under-100-lines-of-Go guide, alongside operating system tutorials such as Writing an OS in Rust and a hardware path called From Blinker to RISC-V in Verilog. There is also a TCP/IP stack tutorial called Let’s code a TCP/IP stack. If you use Docker daily, a container build makes it clearer what the runtime does, and that helps when you hit Docker daemon connection errors.
Languages and developer tools
This is the largest and most varied cluster. It includes Crafting Interpreters, Build Your Own Lisp, Write yourself a Git!, Build Your Own Text Editor (the Kilo editor walkthrough in C) and Write a Shell in C. Several language entries use Haskell, OCaml, F#, Racket or similar tools, so readers curious about functional programming languages will find plenty to build with here.
Data, web and front end
Here you can rebuild the pieces of a web stack. Entries include Build Your Own Database from Scratch (from a B+tree to SQL, in Go), Build Your Own Redis from Scratch in both C++ and Go versions, Browser Engineering in Python and Build your own React in JavaScript. These are strong choices if your day job is web or backend work.
AI and machine learning
The AI Model section lists three entries: building a large language model from scratch in Python (LLMs-from-scratch), a diffusion models course for image generation, and RAG from scratch for document search. The Neural Network section is larger and includes Neural Networks: Zero to Hero and a neural network in 11 lines of Python. A sensible order is to start with a small neural network and move to the larger model builds later. Expect to need Python and some basic math.
Graphics, games, networking and crypto
This cluster is the most visual. Ray Tracing in One Weekend is a well-known 3D renderer entry, and there are game, physics engine and voxel engine tutorials. On the networking side, the README lists a BitTorrent client built from the ground up in Go. A BitTorrent client verifies downloaded pieces by comparing hashes, which is the same idea behind checksum errors that you may have met in everyday troubleshooting.
Which Build Your Own X Project Should You Start With?
The repository does not rate difficulty. The table below is our editorial judgment, built only from entries that appear in the README. The time ranges are rough estimates for a developer working in the evenings, not figures from the repository.
| Level | Good first picks | Rough time (editorial estimate) |
|---|---|---|
| Beginner | Write a Shell in C; a Go cowsay command-line tool; a JavaScript template engine in 20 lines; a regex engine in under 40 lines of JavaScript | A weekend |
| Intermediate | Write yourself a Git (Python); Let’s Build A Web Server (Python); Let’s Build a Simple Database (C); Build Your Own Redis from Scratch; a container in under 100 lines of Go; a small blockchain | One to three weeks of evenings |
| Advanced | Crafting Interpreters; Operating Systems from 0 to 1 or Writing an OS in Rust; Let’s code a TCP/IP stack; Browser Engineering; From Blinker to RISC-V; building an LLM from scratch | One to three months |
| If you would rather choose by goal, use this table. | ||
| Your goal | Start here | |
| — | — | |
| Prepare for technical interviews | Shell, template engine or regex engine, then a database or web server | |
| Understand infrastructure | Docker clone, then a Redis-style server or a network stack | |
| Become stronger at web development | Web server, then a front-end framework or browser build | |
| Learn how AI models work | A small neural network, then the LLM or RAG builds | |
| Learn a new language | The beginner project in that language, using the language labels in the README | |
| A simple 90 day plan works well. Finish one beginner build in the first month, one intermediate build in the second, and make a serious attempt at an advanced one in the third. Write the dates down and add a review point after each build. Treating it as a written professional development plan makes it far more likely you will finish. | ||
How to Choose a Tutorial and a Language
Because every entry links to an outside site, quality varies. Run through these six checks before you commit a weekend to any of the build your own x tutorials.
- Language. Pick the language you already know if speed matters. Pick the one you want to learn if fluency is the goal. The README labels the language of every entry, so filter by it.
- Date. The README does not show when a tutorial was published or updated. Open the page and look for a date, and check whether comments mention problems.
- Link status. Open the link before you plan around it. If it is dead, try the Wayback Machine. The README itself links to an archived copy for at least one entry.
- Tests or checkpoints. A tutorial with tests or a finished reference version lets you see whether you are on track. Many do not have either, so plan to write your own.
- Toolchain. Check that the compiler or runtime versions the tutorial uses still install on your machine.
- License. Each tutorial has its own license. Check it before reusing code. A note on tags: means the guide is a video or playlist, and [pdf] means it is a downloadable document. Use a 30 minute trial rule. Read the first section and run the first example. If you are stuck or bored by then, pick another entry.
A Step-by-Step Method to Finish a Build Your Own X Project
Most people stall because the project is too big or too vague. This eight-step method keeps you moving.
- Define a small scope. Decide in one sentence what finished means, such as a server that answers three commands.
- Read about the real tool. Skim its documentation or protocol specification so you know what you are imitating.
- Build the parser or protocol layer first. Parsing is the first hurdle in many builds, from Redis messages to data formats. Before you write a parser, revisit strict syntax rules such as the JSON syntax rules for brackets and quotes. The README also lists a JSON decoding algorithm walkthrough.
- Get one vertical slice working. Make one command work from input to output before adding another.
- Add tests. Even three small tests will catch regressions.
- Commit often with Git. Small commits make it easy to undo a wrong turn.
- Compare with the real tool. Run the same input through both and note the differences.
- Extend, then write up. Add one feature the tutorial skipped, then write down what you learned.
Worked example: a Redis-style server that answers PING
Redis clients talk to the server using a text protocol called RESP. When a client sends the PING command, it sends an array containing one item, and the server replies with a simple string. The smallest useful server accepts a TCP connection, checks for that message and replies. This Python example does exactly that.
python
import socket
def serve(host="127.0.0.1", port=6380):
with socket.create_server((host, port)) as server:
while True:
conn, _ = server.accept()
with conn:
data = conn.recv(1024)
if data.startswith(b"*1\r\n$4\r\nPING\r\n"):
conn.sendall(b"+PONG\r\n")
else:
conn.sendall(b"-ERR unknown command\r\n")
serve()
Run it, then check it with a real client by pointing redis-cli at port 6380 and sending PING. You should receive PONG back. We confirmed the byte-level exchange by sending the PING and an unknown command over a raw socket, and the replies matched the protocol. From here, add SET and GET with an in-memory dictionary, which is how the longer Redis tutorials in the repository begin.
Limitations of Build Your Own X (and How to Work Around Them)
The repository is excellent at what it does, but it helps to know its edges.
| Limitation | Workaround |
|---|---|
| No difficulty or time labels | Use the level table above and the 30 minute trial rule |
| Links go to outside sites that can disappear | Check the link first and use an archived copy if needed |
| Age and quality vary by entry | Check dates, comments and tool versions before starting |
| Most tutorials have no tests or grading | Write your own tests or compare against the real tool; a guided platform is another option |
| Claims about freshness conflict across sources | Judge by GitHub itself: commit history and open issue and pull request counts |
| It is a list, not a curriculum | Plan your own sequence using the 90 day approach |
| On freshness specifically, readers will find mixed signals online, including comments saying the repository is no longer updated. The most reliable evidence is the repository. On October 27, 2026, GitHub showed 616 commits, 285 open issues and 396 open pull requests. A large queue of open pull requests suggests that contributions arrive faster than they are merged, so expect some gaps and stale entries. |
Using Build Your Own X for Team Onboarding and Upskilling
Build-from-scratch projects can also help teams. These are suggestions, not guarantees.
- A one week mini-build. Pick a system your team runs and rebuild a toy version. A team that relies on Redis might build a small cache server like the example above.
- Pairing and review. Review the toy build together. Explaining design choices in code review spreads understanding.
- A fair hiring exercise. If you use a build as a hiring task, keep the scope small and the time limit fair.
- Scoping what to rebuild. Not every system deserves a rebuild. Choose the ones where deeper understanding would reduce real risk. If you want help deciding which internal systems are worth a mini rebuild, a technical consultation can help you scope it.
Where to Go After Build Your Own X
When you finish a few projects, these resources are natural next steps.
- Crafting Interpreters for a full, book-length path through building a language.
- From NAND to Tetris (listed under Uncategorized in the README) for building a computer from first principles.
- The build-your-own.org books on Redis, databases, web servers, compilers and regex engines, several of which appear in the repository.
- LLMs-from-scratch for a deeper path into language models.
- project-based-learning, another curated list of project tutorials that appears in comparisons with this repository. The best way to use what you built is to ship something small that solves a real problem. After building a model from scratch, a problem-first approach helps when you move on to agentic AI applications.
Frequently Asked Questions About Build Your Own X
What is build-your-own-x?
It is a free GitHub repository of curated, step-by-step tutorials for rebuilding technologies such as databases, shells, Git and operating systems from scratch. It links to tutorials hosted elsewhere and is organized by category and programming language.
Is Build Your Own X free, and can I use the code commercially?
Reading the list is free, and the list itself is released under a CC0 waiver. Each linked tutorial has its own license, so check the license of any tutorial before reusing its code in a commercial project.
Who maintains Build Your Own X?
The project was started by Daniel Stefanovic and is now maintained by CodeCrafters, Inc., according to the repository README.
Is Build Your Own X suitable for beginners?
Some entries are, such as writing a simple shell or a small template engine. Others, such as operating systems or compilers, are advanced. The repository does not rate difficulty, so use the level table in this guide.
Which programming language should I use?
Use the language you already know if you want to finish quickly, or the one you want to learn if fluency is the goal. The README labels each tutorial’s language, so you can filter by it.
How long does a project take?
It depends on the project. As rough editorial estimates, a beginner build takes a weekend, an intermediate build one to three weeks of evenings, and an advanced build one to three months. The repository gives no official times.
Does it include AI and LLM tutorials?
Yes. The AI Model section lists a large language model built from scratch in Python, a diffusion models course and RAG from scratch for document search. The Neural Network section has many more entries.
Is Build Your Own X still maintained?
Check GitHub for the latest commit date. On October 27, 2026, the repository showed 616 commits, 285 open issues and 396 open pull requests, and sources online disagree about how actively it is updated.
Conclusion: Pick One Project and Finish It
The value of build-your-own-x is not in browsing the list. It is in finishing one project. Pick a beginner entry that matches a language you know, use the checks and the eight-step method above, and move up a level when you are done. Start from the repository on GitHub and choose one. For teams planning real products rather than practice builds, software development consulting is the natural next step.