15 Rust Projects To Elevate Your Skills in 2025

You have read through Rust basics and done some exercises.

Now you want to build some actual projects and get hands-on experience.

Here's a list of 15 curated projects, ordered by difficulty, to help you:

• apply Rust's core concepts in real-world scenarios
• get comfortable with ownership, borrowing and lifetimes
• optimize performance with zero-cost abstractions and concurrency
• build everything from auth servers to browser engines

Pick a project, start building, and deepen your Rust expertise.

Beginner Rust Projects

Project 1: CLI To-Do List App

A terminal app to track tasks without cmd/alt-tabbing is perfect for developers who live in the terminal.

• Add, delete, and track tasks
• Mark them as done or TBD
• Save them to a file so they persist

Add features to make it more useful.

• Create tasks with a deadline
• Tasks that repeat on a set interval

You'll find that Rust forces you to handle potential issues like missing files or invalid input, ensuring reliable code.

Take a look at this app.

Skills you'll pick up - File I/O, error handling, testing, iterators

Project 2: Web Scraper for E-Commerce

Web scrapers can monitor price changes, tickets and limited drops so you get notified before everyone else.

Try to extract product data from this dummy e-commerce site.

• Crawl all pages
• Parse product details
• Save data

On real sites, you'll face problems like client-side rendering and cookie walls.

You can improve your app to scrape Airbnb using a webdriver with thirtyfour.

While scraping speed is independent of programming language, Rust's iterators and functional paradigm simplify data searching and make it intuitive.

Check out this source code.

Skills you'll pick up - HTML parsing, web scraping, functional programming

Project 3: File Compression

Compression is everywhere from email storage to video streaming. A good way to understand the fundamentals is by compressing a text file.

Create a program to -

• compress
• extract
• benchmark performance

You can use any effective compression algorithm like Huffman Coding.

Rust's bit-level control and parallelism will let you optimize beyond traditional tools. Use a large .txt file and measure how your program performs.

This Rust code outperforms zip in both compression rate and speed.

Skills you'll pick up – Lossless compression, bit control, parallel computation

Project 4: Real-Time Chat Room

Create a chat room to hide your conversations from big tech servers and the powers that be. (For legal purposes, this is a joke.)

• multiple users per room
• real-time message updates
• simple frontend with HTML & JavaScript

You can now add security.

• authentication
• end-to-end encryption

Rust's async model and lightweight concurrency make it great for building chat apps.

Check out this neat chat app built in Rust.

Skills you'll pick up – Networking, websockets, async programming, concurrency

Project 5: Search Engine

Apps today let you search through collections of text documents like chats, news articles, and emails. Build a search engine to understand the basics.

You can start with a program that ranks text documents against a query.

• inverted index : tokenization with stemming, lemmatization, etc.
• ranking algorithm : relevance metrics like BM25, window score, etc.

Add spelling correction and predictive search to improve search experience.

Here's a sample dataset of Wikipedia articles you can work with.

Add a regex mode with Rust's regex engine which uses finite automata and SIMD to make it blazing fast. ripgrep uses it to outperform grep.

Check out this implementation of a search engine in Rust.

Skills you'll pick up – Text processing, search algorithms, query optimization

Intermediate Rust Projects

Project 6: API Server for Dog Walking Bookings

Building an API is a rite of passage in any language. Time to do it in Rust.

For example, you can build a REST API to manage dog walking bookings.

• Add owners and their dogs
• Schedule and manage bookings
• List all upcoming bookings
• Assign a walker to a booking
• Cancel a booking

Use a NoSQL database like MongoDB to store the data.

Make it production-ready -

• stress-test your API and optimize database queries
• use a constraint-solving algorithm (e.g., Z3) to auto-assign walkers
• implement surge pricing based on demand.

Rust's async runtime and type safety make it ideal for building fast, reliable API servers.

With Tokio's async runtime, you can handle many requests concurrently without blocking threads.

Check out this guide.

Skills you'll pick up – API dev, async programming, MongoDB, web frameworks

Project 7: Authentication System with Sessions

Build your own user authentication and see what it entails.

Here's what you can implement -

• User signup and login
• Secure password storage
• Session management with cookies
• Authentication middleware for protected routes
• Simple frontend

You can also try -

• authentication with JSON Web Tokens (JWT) instead of sessions
• adding multi-factor authentication

The debate between sessions vs JWTs for auth has been going on for years - this video breaks it down.

Rust's ownership model eliminates some common security flaws like use-after-free and buffer overflows.

Its lifetimes and borrow checker enable you to manage sessions without worrying about memory leaks.

Check out this guide with source code. For JWT auth, check this.

Skills you'll pick up – Auth, password hashing, sessions, middleware

Project 8: Version Control System (Git)

Reinvent the wheel and build a lightweight Git clone that tracks changes in source code. (because understanding Git internals is worth it)

To do this, you must read about .git directories, blobs, trees and commits.

Few features you can start with-

• initialize a .git directory
• read and write blob objects
• create tree structures
• commit changes

You can then implement git clone, which is more complex.

Rust's zero-cost abstractions let you manage Git's object storage efficiently, with no runtime overhead.

Take a look at this source code.

Skills you'll pick up – Git internals, object storage, hashing, data structures

Project 9: BitTorrent Client

Decentralized file sharing powers everything from Linux ISOs to, well… you know. Build a BitTorrent client to see how it all works.

You first need to understand the BitTorrent protocol.

It might be a good idea to start with single-file torrents.

You'll need to implement -

• .torrent parsing
• peer discovery and connection
• file download and verification

You can use this sample single-file torrent for a txt file.

Once you can download it, add support for -

• magnet links
• multi-file torrents
• seeding

Rust ensures memory safety without a garbage collector, enabling low latency and reliable performance while handling peers concurrently.

Watch Jon Hoo build a client in Rust. Here's the source code.

Skills you'll pick up – P2P networking, hashing, low-level data transmission

Project 10: Video Call App

Build an app for video calls and learn how to leverage WASM.

Here's what you can implement -

• Web-based peer-to-peer calls
• Signaling server using WebSockets
• Rust compiled to WASM for browser compatibility

You can use WebRTC to handle video and audio streaming.

The frontend can be a simple HTML page with some buttons, and video elements.

You can also add features like -

• Group calls
• Screen sharing
• End-to-end encryption

Rust-to-WASM helps integrate Rust with projects written in other languages. Rust can then replace slow parts with faster, memory-efficient code.

Check out this source code.

Skills you'll pick up – WebRTC, Rust-to-WASM, async networking, peer connections

Advanced Rust Projects

Project 11: Wordle Solver

Build a program that solves Wordle, with the help of information theory.

This challenge comes from the Jon Gjengset YouTube channel.

To get started - watch this video to understand the algorithm. get the Wordle dictionary and list of Wordle answers. download the Google 1-grams dataset to get word occurrences.

Once you are ready,

• create the solver
• benchmark speed
• optimize the solver

Benchmark performance using hyperfine and improve it as much as possible.

Rust excels at high-performance tasks, and this project gives you hands-on experience optimizing computations over a large search space.

Watch Jon's video as he optimizes the solver, and try to outperform his code.

Skills you'll pick up – Performance optimization, probability, benchmarking

Project 12: SQL database Engine

Writing SQL is easy. But writing the engine that runs it is not.

Build a simple SQL engine that reads .db files and executes queries.

You can start here -

• Read and parse SQLite database files
• Execute basic SELECT query with WHERE clause
• Use indexes for faster data retrieval

You need to understand B-trees and how SQLite stores data on disk.

Try running this query on companies.db with your engine in less than 4 seconds.

$ ./your_program.sh companies.db "SELECT id, name FROM companies WHERE country = 'eritrea'"

121311|unilink s.c.
2102438|orange asmara it solutions
5729848|zara mining share company
6634629|asmara rental

You can also extend support for more clauses and query optimization.

Rust's memmap2 enables efficient SQLite page access with direct RAM-speed B-tree traversal instead of reading the entire file into memory.

Check out Brooks Patton's implementation.

Skills you'll pick up – B-trees, SQL engines, SQLite internals, indexing

Project 13: Lox Interpreter

Build an interpreter for Lox, a simple scripting language, and understand how languages come to life.

The project comes from Crafting Interpreters by Robert Nystrom.

Before starting, read the welcome section of the book here -

• Introduction (chapter 1)
• A Map of the Territory (chapter 2)
• The Lox Language (chapter 3)

Building an interpreter involves complex engineering and some novel concepts.

Here is an overview of the steps -

• Scan tokens
• Represent code
• Parse expressions with an AST
• Evaluate expressions
• Handle statements and state
• Support implicit declarations
• Add control flow
• Support user-defined functions and execution

Once it is running, try optimizing it or adding new features-

• Bytecode compilation for faster execution
• Automatic memory management
• Built-in functions for usability

Rust's enum + match approach makes it easier to define and process syntax tree nodes efficiently.

It manages interpreter state without GC, making you consider lifetimes, references, and memory safety in ways uncommon to dynamic languages.

Jon Hoo built this over an 8-hour YouTube stream. Here's the code.

Skills you'll pick up – Tokenization, ASTs, tree-walk interpreters

Project 14: Browser Engine

Build a very basic web browser from scratch. No Chromium, Gecko, or WebKit.

• Parse and render simple HTML & CSS
• No JavaScript, animations, or advanced layouts
• Single-threaded sync page loading. Okay to be slow.

As the first goal, you can match how a real browser renders this HTML file.

You can then push further -

• Support multiple pages
• Add a caching layer
• Load web pages over HTTP instead of just local files
• Offload rendering to a separate thread for performance

Rust's memory safety and performance make it a good choice for browser engines. Servo, Mozilla's research browser, is written in Rust.

Josh On Design's blog series walks through building a Rust browser engine.

Skills you'll pick up – Parsing, rendering, layout algorithms, systems programming

Project 15: NES Emulator

Run the first Super Mario Bros on it's original hardware that you emulate in software.

To do this, you'll have to create an NES emulator -

• Implement the 6502 CPU with instruction handling
• Support iNES format ROMs and mapper 0 (NROM)
• Render graphics with the PPU (without scrolling first)
• Add scrolling for full game support

This NES ebook can help you implement all the steps.

Use these ROMs to test and debug your code.

Start by running Donkey Kong as your first goal.

Then add support for Super Mario Bros and any other NES games you want.

You can complete your emulator by adding -

• APU (audio processing unit)
• more mappers to support other games

Rust lets you write high-level, expressive code (like pattern matching for CPU opcodes or iterators for memory access) without sacrificing performance.

The compiler optimizes them, making your emulator as fast as one written in C.

At the same time, Rust's borrow checker ensures safe memory access, preventing common emulator bugs like use-after-free or buffer overflows that are common in C/C++.

Check out this NES emulator written in Rust.

Skills you'll pick up – CPU emulation, memory management, binary parsing, graphics rendering, low-level systems programming.

Conclusion

Rust is the most admired programming language among developers today.

Tech leaders are choosing Rust to build and maintain critical systems:

• Google's shift to Rust has cut Android memory vulnerabilities by 68%.
• Discord switched from Go to Rust for better performance and security.
• Cloudflare chose Rust for 1.1.1.1 due to its elegance & lightweight design.

At the same time, the Rust community uses it for projects like :

• operating systems
• game development engines
• embedded systems

If you are a programmer, mastering Rust now makes a lot of sense.

By completing these projects, you'll gain the skills to build everything from high-performance APIs to game engines, compilers, and creative tools.

What's next?

1. Join the Rust community - User Forum, Reddit, Discord
2. Contribute to open source to collaborate with experienced developers.
3. Start using Rust for work, open-source or personal projects.

Keep building, keep exploring, and most importantly, enjoy the journey!