Learn Rust by Building Real Applications (Udemy.com)

A great course (fully example driven) and a worthy learning experience! Covers all the basic aspects of Rust while being completely example-driven. The instructor did a great job of providing the use case first and then explaining the concept which reinforces the understanding of Rust. This course is a great starting point for anyone planning to learn Rust in 2026. The HTTP server project clearly covers a huge chunk of the core rust like Strings, &strs, references, lifetimes, traits, enums, vectors, hashmap etc. These concepts were brilliantly explained and since the examples live and work in front of our eyes, it is very easy to comprehend them. The initial sections with the explanation for the basics of stack and heap, functions and ownership were elegant and very informative. The concepts of Lifetimes and Dynamic Dispatch was well explained (with examples in each case). I had to go through Section 4 multiple times taking notes and practicing (with Rust Playground) to fully grasp the instructor's expertise. Lifetimes took me the most time to understand and required me to dive deep (where I got to learn about Covariance, Contravariance and Invariance). I did try out a lot of examples using structs, traits and generics to fully comprehend lifetimes. Modules in rust were explained step by step staring from creating simple in-file modules to multiple modules nesting in a folder. These aspects were properly explained with multiple examples. Traits (especially the display, debug, from, into, try_from were informative) and enums were handled and explained in the best possible way. The first 3 sections took me a week (with notes and practice to complete), and the last section took me over 2 months (multiple re-visits, notes and practice).

This course looks to me like an excellent introduction to Rust for developers with experience in other languages like C++. It's just a pity that it hasn't been updated to fix the chars().enumerate() vs char_indices() issue in Lecture 41 (see Q&A for this lecture). And since Rust 1.89.0, there are some new warnings around lifetimes which are emitted for the example code, but this is relatively minor.

This was a great course! While a bit dated on some of the compiler error/warnings, it still holds up well in 2026. Like many others, I did struggle a bit on the gdb module, but I loved the explanations & examples of the memory vs heap. Coming from C#, I never had to learn about memory management, and Rust definitely brings memory management front-and-center. Honestly, I felt like this course did more to explain memory management than other blogs I've tried reading on the web. I still don't have a solid grasp on lifetimes & borrowing, but I think these concepts will solidify in time as I continue to grow in Rust. This course was laid out very well using the idea of building a rudimentary API server, and Lyubomir's teaching style was perfect for the way I like to learn. He wasn't concerned on trying to make a fully-featured API server, but rather used the project as a concrete way to show you how to use Rust. This was my first experience with Rust and with so many new concepts to learn, I am very grateful he didn't dive into things like asymmetric functions, threading, or even writing macros. He kept everything simple, bite-sized, and straight to the point. I loved section 4 where each lesson built on top of the previous because he initially shows you a direct way to write a piece of code, but then occasionally revisits that approach to make it more idiomatic with Rust. I know there's a lot of Rust courses out there, but honestly, it's rare that I find courses taught so well like this one was! Well done, and thank you!

This Rust course is absolutely amazing! The instructor explains concepts clearly and thoroughly, making complex topics like ownership, lifetimes, and concurrency easy to understand. I feel much more confident writing safe and efficient Rust code. Highly recommend for anyone wanting to master Rust!

wrong description

If you have some basic knowledge of Rust, than this is great place to do project based learning. Personally I believe we need more project-based tutorials, instead of an ocean of fundamentals videos, to better connect the dots for us new to Rust and it's ways of doing things. Lyubomir thank you for putting this together, super helpful.

Take this course after taking an some introduction to Rust course because you will learn the implementations of the knowledge you learn theoratically before. I highly suggest this course because the lecturer mentions why he use this word, how this function is using, etc. You will find it more logical and sensible.

The course was definitely worth It as It starts with basic concepts and gradually moves to the advanced concepts and also giving strong fundamentals on how the compiler works underneath, making little improvements to problems from previous sections. It is not really beginner-friendly but It does a good job In explaining Rust

Excellent course. The already steep curve becomes steeper from around Session 40 onward, and Lyubo's explanations, though always very thorough, become a bit fast/complex for the beginner such as myself. Luckily, there are enough resources online to compliment the course's rewatchability.

A course that goes into the basics of Rust with the help of a server program implementation in Rust. Each video smoothly goes into a new Rust feature in the guise of a continuance of implementation of different parts of the server program. The course was very well-structured and I feel deserves the rating given.