Track
Master the C programming language, the backbone of system programming and software development. Build a solid foundation in memory management, algorithms, and low-level programming.
Start here
A utility that reads a text file and provides statistics about its content. It should report the total number of characters, words, lines, and the frequency of each character or word.
Sign in to track progress
Basic
4 projectsA utility that reads a text file and provides statistics about its content. It should report the total number of characters, words, lines, and the frequency of each character or word.
A practical command-line tool to manage daily tasks. Users can add tasks, list all tasks, mark tasks as complete, and delete tasks. The list of tasks should persist between program runs by saving to and loading from a file.
Create a classic Hangman word-guessing game that runs in the command line. The program should select a random word from a predefined list (stored in a file), display the progress (e.g., `_ _ _ _`), and track incorrect guesses.
Build a command-line tool that can encrypt and decrypt files using a simple XOR cipher with a user-provided key. The tool should read an input file, apply the XOR operation byte-by-byte, and write the result to an output file.
Intermediate
5 projectsCreate a simple engine for text-based adventure games (Interactive Fiction). The engine will read game data (rooms, items, descriptions) from configuration files and allow a player to navigate the world, interact with objects, and solve puzzles using text commands like 'go north', 'get lamp'.
Write an emulator for the CHIP-8, a simple interpreted programming language used on old microcomputers. This involves emulating the CPU, memory, graphics, and input. This is a classic and highly rewarding project for understanding how computers work at a low level.
Build a command-line tool that can fetch content from a URL, similar to `wget` or `curl`. The tool will take a URL as an argument, perform a DNS lookup, establish a TCP connection, send an HTTP GET request, and print the server's response (headers and body) to the console or save it to a file.
Develop a command-line application to manage a small library's book inventory. Users should be able to add new books, search for books (by title, author, or ISBN), list all books, borrow books, and return books. Data should persist between sessions using files.
Create a basic command-line spreadsheet application. It should support a grid of cells, allow users to enter numeric values or simple formulas (e.g., SUM(A1:A5)), display the grid, and save/load the spreadsheet state to a file.
Advanced
6 projectsCreate your own command-line shell that can execute user commands. The shell should display a prompt, read a line of input, and execute the command with its arguments. It should support running external programs, a few built-in commands (like `cd`, `exit`), and I/O redirection (`>`, `<`).
Implement an interpreter for a small subset of the Lisp programming language. This project, often called 'Build Your Own Lisp', is a fantastic exercise in parsing, evaluation, and memory management. You will create a program that can read Lisp code as text, evaluate it, and print the results (a REPL).
Build a simple, file-based database engine that functions as a key-value store. The engine will provide an API to `set`, `get`, and `delete` key-value pairs, and all data will be persisted to disk, ensuring durability between sessions. To make it efficient, you'll need to implement an in-memory index.
Implement your own versions of `malloc`, `free`, `calloc`, and `realloc`. This involves managing a pool of memory obtained from the OS (e.g., using `sbrk` on Unix-like systems or `HeapAlloc` on Windows, or simply a large static array for simplicity) and implementing strategies like first-fit or best-fit for allocation.
Develop a basic version control system inspired by Git. It should be able to 'commit' snapshots of a tracked directory, store these snapshots efficiently (e.g., using content-addressable storage with hashing), view commit history, and potentially 'checkout' previous versions. Focus on the core snapshotting mechanism.
Create a simulator that models the behavior of different CPU scheduling algorithms (like First-Come First-Served, Shortest Job First, Priority, Round Robin). The simulator should take a list of processes (with arrival times, burst times, priorities) as input and output statistics like average waiting time and turnaround time.
Expert
5 projectsA highly challenging but rewarding project: build a compiler for a small subset of the C language. The compiler will take a source file written in your 'Toy C' dialect and produce corresponding x86-64 assembly code. This provides a fundamental understanding of how high-level code is transformed into machine-executable instructions.
Implement a significant portion of the TCP/IP networking stack from scratch in user-space. Your program will use a TUN/TAP virtual network interface to receive raw IP packets from the kernel and will handle them according to protocol standards. This project offers an unparalleled deep-dive into the mechanics of modern networking.
Build a tool that synchronizes files between two directories, potentially over a network. It should efficiently transfer only the differences between files, similar to how rsync works. Implement a basic version using checksums or modification times to detect changes.
Implement a library of optimized data structures in C, focusing on performance and memory efficiency. Examples include skip lists, B-trees, or lock-free/wait-free structures like a concurrent hash map (using atomic operations). Provide a clean API and extensive testing.
Develop a minimal operating system kernel that can boot (perhaps using GRUB), initialize basic hardware (like the console for text output), manage physical memory (a simple frame allocator), and potentially load and run a single user-space program or implement basic multitasking (cooperative or pre-emptive with timer interrupts). This is highly challenging and educational.