Project Ideas for each language
Go (Golang)
Specialty: Simplicity, high-performance concurrency (Goroutines/Channels), and building robust networked services. It excels at “boring but critical” backend infrastructure.
Tier 1: Concurrent Web Scraper (The “Hello Concurrency” Project)
The Project: Build a CLI tool that takes a list of URLs and fetches them all simultaneously, reporting the size and status code of each.
What You Learn: This forces you to leave the single-threaded mindset. You will learn to spawn Goroutines (lightweight threads) and use Channels to safely communicate data back to the main thread without locks or race conditions.
Key Feature Used: go func(), chan, sync.WaitGroup
Tier 2: Load Balancer or Rate Limiter
The Project: Create a reverse proxy that sits between a user and multiple dummy web servers. It should distribute traffic (Round Robin) or reject requests if a user sends too many per second.
What You Learn: This is the bread and butter of Go. You’ll deal with standard library networking (net/http), managing high-throughput traffic, and implementing algorithms that need to be thread-safe.
Key Feature Used: net/http/httputil, sync.Mutex, buffered channels
Tier 3: Distributed Key-Value Store (A Mini Redis)
The Project: Build an in-memory database that can be accessed over TCP. Support commands like SET, GET, and DEL. Add replication where one server copies data to another.
What You Learn: You will learn how to build network protocols from scratch and manage memory in a long-running application. Adding replication teaches you about distributed consensus and eventual consistency.
Key Feature Used: TCP socket programming, custom serialization, strict concurrency patterns
Rust
Specialty: Memory safety without garbage collection, ownership/borrowing model, and zero-cost abstractions. It forces you to think about who owns this data and how long does it live.
Tier 1: A Multi-threaded Grep Tool
The Project: Re-create the command-line tool grep. It should search a file (or directory) for a text string. Make it faster than the default terminal version by searching multiple files in parallel.
What You Learn: You’ll hit the borrow checker immediately. You have to figure out how to share read-access to strings across threads without copying them unnecessarily.
Key Feature Used: Ownership, Borrowing (&str vs String), std::thread, and result handling (Result<T, E>)
Tier 2: HTTP Server with Thread Pool
The Project: Build a web server from scratch (without a framework like Axum first). It should listen on a TCP port, parse raw HTTP requests text, and send responses. Use a fixed pool of threads to handle connections.
What You Learn: This teaches you “Fearless Concurrency.” You will learn how to safely share state (like a cache or counter) across threads using Arc (Atomic Reference Counting) and Mutex, ensuring no data races compile-time.
Key Feature Used: Arc, Mutex, std::net, lifetimes
Tier 3: An Embedded OS Kernel or Game Boy Emulator
The Project: Write a tiny kernel that boots and prints to the screen, OR a Game Boy emulator (Chip-8 is a good warmup).
What You Learn: This shows off Rust’s ability to act as a low-level systems language. You will manage raw memory and CPU registers while still using safe abstractions where possible. It proves you don’t need C for hardware access.
Key Feature Used: unsafe blocks, bitwise operations, hardware mapping, no_std environments
Zig
Specialty: “Better C.” No hidden control flow (no operator overloading, no hidden allocations), first-class support for compile-time code execution (comptime), and manual memory management made explicit.
Tier 1: A Hex Dumper / Binary Inspector
The Project: A tool that opens any file and prints its binary content in a readable hex format (like xxd).
What You Learn: Zig forces you to handle allocators manually. You can’t just “create a string”; you must pass an allocator to the function that creates it. This projects teaches you how to read files and format output without a hidden runtime.
Key Feature Used: std.fs, std.debug.print, basic slices
Tier 2: Generic Data Structure (using Comptime)
The Project: Implement a generic List or HashMap that can work with any data type, optimized at compile time.
What You Learn: Zig doesn’t have C++ style templates or Rust generics; it uses comptime. You will write code that runs during compilation to generate the types you need. This is Zig’s superpower.
Key Feature Used: comptime, type as a value, @import
Tier 3: HTTP Server with Custom Memory Allocator
The Project: Build a basic HTTP server, but write a custom memory allocator (e.g., an arena allocator) specifically optimized for the request lifecycle.
What You Learn: In other languages, swapping the memory allocator is hard. In Zig, the allocator is just an argument you pass to functions. You will see how manually managing memory lifecycles can lead to massive performance gains.
Key Feature Used: std.mem.Allocator, Arena allocators, non-blocking I/O
Elixir
Specialty: Fault tolerance, massive concurrency (millions of processes), and real-time reliability. It runs on the BEAM VM (Erlang), making it perfect for systems that must never crash.
Tier 1: Real-time Chat App (The “Hello Phoenix” Project)
The Project: A chat room where multiple users can type and see messages appear instantly without refreshing the page.
What You Learn: Elixir handles WebSocket connections (channels) trivially. You will see how easy it is to broadcast state to thousands of connected clients.
Key Feature Used: Phoenix Framework, Phoenix Channels, Pattern Matching
Tier 2: A Supervisor Tree for a Weather Monitor
The Project: Build a system that fetches weather data for 50 different cities. Each city should be its own “process.” If fetching fails for one city and the process crashes, a “Supervisor” should detect it and restart just that process, leaving the others alive.
What You Learn: This teaches “Let it Crash.” Instead of catching exceptions, you design a supervision tree that heals the system automatically. This is the core philosophy of Erlang/Elixir.
Key Feature Used: GenServer, Supervisor, Process linking
Tier 3: Distributed Key-Value Store (Nodes)
The Project: Similar to the Go project, but here you run the app on two different terminal windows (nodes) and have them communicate natively. If you kill one node, the other should know.
What You Learn: Elixir has distributed computing built-in. You can send a message to a process on a different computer as easily as to one on the same RAM stick. You will learn about the Node module and distributed message passing.
Key Feature Used: Node.connect, :rpc, distributed Erlang