Rust from Scratch for free: we're launching the fourth programming course on Shanraq.org

We have begun developing the fourth free course on Shanraq.org —
“Rust from Scratch”. It follows courses on Go, Python, and SQL. Now
a language that differs markedly from the previous three is joining them.

Rust demands greater care with memory, data lifetimes, and ownership.
It tries to catch many errors before the program even runs. This is
precisely why Rust is considered a difficult language for beginners —
and precisely why we decided to create an introductory course for it.

This is not a “Rust in Seven Days” course, nor a collection of code
snippets to copy and paste. We want to build a measured path from the
first program to an understanding of why Rust works the way it does.

The course will be free. You can read the lessons without mandatory
registration and at your own pace.

Open free courses on
Shanraq.org

What Rust Is and Why Learn It

Rust is a general-purpose programming language with particular emphasis
on performance, memory safety, and concurrency. Its fundamental
difference becomes apparent even in early serious programs.

In languages with automatic garbage collection, the programmer largely
delegates memory management to the runtime. In C and C++, a significant
share of responsibility remains with the programmer. Rust offers a
different approach: it has no traditional garbage collector, yet the
language strives to ensure memory safety through a type system and
rules enforced by the compiler.

The central concept here is ownership. A value has an owner. When the owner ceases to exist, the corresponding resources are freed. Transferring a value, temporary borrowing, and mutating data are governed by rules that the compiler checks before the program runs.

At first this may seem like an extra obstacle: you wrote a program that looks correct, but the compiler rejects it. Gradually it becomes clear why it pushes back. The compiler forces you to deal with the problem before the program reaches the user.

Why we chose Rust

There are several reasons. Rust is interesting not only for its syntax: it makes you reason differently about data, resources, and how a program is structured.

Rust teaches you to understand what happens to data

A beginning programmer fairly quickly gets used to writing:

let name = String::from("Shanraq");

But behind this simple line lies a whole chain of questions: where the data lives, who owns it, what will happen when the value is passed to another function, whether temporary access can be granted without giving up ownership, and who will ultimately free the memory.

Rust forces you to ask these questions. For a beginner this is harder than simply memorizing syntax, but gradually an understanding emerges of what happens in a program below the level of visible lines of code.

Many problems are caught at compile time

The Rust compiler is rather strict. This sometimes irritates even experienced developers, and a newcomer all the more so. But this strictness serves a practical purpose.

If a program violates the rules of types, ownership, or borrowing, in many cases it simply won’t compile. The error appears in front of the developer while working on the code, not a week later on the user’s computer.

That’s why we want to teach not fighting the compiler, but reading its messages and understanding what problem it is trying to prevent.

Rust is needed not only for academic tasks

Rust is used where performance and control over resources are simultaneously important: in systems programming, server applications, developer tools, network software, embedded systems, and other areas.

Developer interest in the language remains high. In the Stack Overflow Developer Survey 2025, Rust once again turned out to be the most highly rated language in the Admired category: 72% of developers who had worked with it wanted to continue using it.

This does not mean that Rust is the best language for any task. Such a language does not exist at all. But it is a good reason to understand why developers who have already passed through its initial complexity so often want to continue working with it.

Why not start right away with the official Rust book

You can start. The official book The Rust Programming Language, which developers usually simply call The Book, is one of the main sources on the language. We ourselves will constantly be cross-referencing the official documentation.

But there is an important detail: the authors of Rust Book assume that the reader is already somewhat familiar with programming. The book does not set itself the task of explaining in detail from the very beginning what a program is and how to reason when creating one.

Our course solves a slightly different problem. We want it to be accessible to someone who has never written in Rust, including those with limited prior programming experience. That’s why we’ll explain some things more slowly: not just what to write, but also why it’s needed, what just happened, and what would change if you did it differently.

What We’ll Learn

We’ll start with installing Rust, the first program, compilation, rustc, and Cargo. Then we’ll break down variables, types, functions, conditions, and loops — the basic building blocks without which it’s impossible to move forward.

After that, we’ll gradually move on to the features that make Rust truly worth learning: ownership and moving values, references and borrowing, mutable references and slices. Then come structs, enums, Option, Result, match, collections, strings, modules, and error handling.

In later stages, we’ll cover generics, traits, lifetimes, closures, iterators, smart pointers, multithreading, and concurrent programming.

But listing topics isn’t enough. Our task is to connect them so that ownership doesn’t remain just one “scary chapter” to endure and forget. It will keep coming back in functions, structs, collections, and threads, until it becomes a natural way of thinking about programs.

Cargo — From the Very Beginning

We’ll separately learn to work with Cargo — Rust’s standard build system and package manager. Cargo creates project structure, builds and runs programs, executes tests, and manages dependencies.

For example:

cargo new hello_rust
cd hello_rust
cargo run

These three commands create a new project and run it. We don’t want to spend several weeks studying Rust in separate files first, only to suddenly introduce the reader to how a real project is structured. That’s why Cargo will appear almost immediately: we’ll learn in the same environment where programs are actually written.

Not Memorizing Prohibitions, but Understanding the Rules

One of the dangers when learning Rust is turning ownership into a set of mechanical recipes: “put & here,” “add mut here,” “do .clone() here — and the error goes away.”

You can make the program compile this way, but Rust itself will remain incomprehensible.

We want to go in the opposite direction. If the compiler rejects a program, we’ll first figure out what value exists, who owns it, whom we’re trying to transfer it to, whether ownership really needs to be transferred or it’s enough to temporarily borrow the value. And only after that will we fix the code.

We’ll be especially careful with .clone(). Cloning is sometimes truly necessary. But if a beginning developer adds .clone() every time the compiler complains about ownership, they eliminate the error message without eliminating the misunderstanding of its cause.

How the Lessons Will Be Structured

We’re keeping the approach we use in other Shanraq courses. First, the reader will see a small working program and the result of its execution. Then they’ll break down the code piece by piece and connect the new topic with concepts they already know.

At the end of each lesson there will be a compact map to help you reconstruct the content. After working through the explanation, you’ll need to close it and answer a few questions in your own words. Only then will an independent exercise appear.

The principle is simple: reading code does not mean being able to write it. So after each lesson, the reader will have to do something without a ready-made solution in front of them: modify or extend a program, find an error, explain the result, or write and run a small piece of code independently.

A compiler error is also part of the lesson

In a typical textbook, incorrect code is often deliberately not shown. In the Rust course, we will sometimes do the opposite: deliberately write a program that the compiler will reject.

For example, we’ll pass a value to a function and then try to use it again. We’ll look at the compiler’s message, break it down, fix the program one way, then another, and compare the solutions.

For Rust this is especially important: part of the language is effectively learned through dialogue with the compiler. So our goal is not to reach a state where the student never sees errors. The goal is different: to see the error, understand its cause, and know what to do next.

Rust after Go, Python, and SQL

The four Shanraq courses should not repeat one another. Each has its own purpose.

Go shows how to build a real network service from a comparatively small number of straightforward parts. Python lets you quickly move on to data, automation, analysis, and then to machine learning and AI. SQL teaches you to ask precise questions of data and understand the relational model. Rust goes deeper into how a program works: memory, resource ownership, types, safety, and concurrent execution.

So the question “which is better — Go, Python, or Rust?” is framed incorrectly. It all depends on the task. For rapid data exploration, Python is often more convenient. For a simple and clear server-side service, Go may be a good choice. For working with data in a relational database, you need SQL. And when it’s important to deeply understand memory management, safety, and performance, Rust comes into play.

These languages in our courses do not compete with each other. They are different tools and different ways to learn to think about programs.

Can Rust be studied as a first language

You can, but it will be harder — and we don’t want to hide this behind marketing promises. Even the official Rust book assumes some prior programming experience.

For someone who has already completed our Go or Python course, many basic concepts will be familiar: variable, function, condition, loop, data structure. So more attention can be devoted to Rust’s distinctive features.

However, completing previous courses will not be a mandatory requirement. If any concept is necessary for understanding the current lesson, we must explain it within the course itself or provide a clear link to additional material. The phrase “you should already know this” is a bad explanation.

Free means free

Nothing changes here compared to other Shanraq courses. Lessons can be read for free, with no mandatory registration required. There are no introductory lessons followed by a payment form, and no paid “advanced level” where the most useful material gets moved.

We also don’t promise to turn someone into a Rust developer in a month. There’s open learning material, a computer, and as much time as a particular person needs. If one reader completes a lesson in an evening while another takes a week to work through it — both are learning just fine.

The course is still being created

This is important to say up front: the Rust course is not yet finished. We’ve only just begun developing it and will be publishing lessons gradually.

So the first readers will be able to influence the result. If an explanation is unclear, we’ve skipped a necessary concept, or an example works for us but not for you — it’s worth writing about that. If you already program in Rust and see that an example is technically correct but teaches a beginner bad practice, that kind of comment is especially valuable.

The course should improve not because the author thinks it’s good, but because readers can actually learn from it.

What comes next

Rust has become the fourth direction of free courses on Shanraq.org. The educational trajectory now looks like this:

Go — programming and web development;
Python — programming and data work;
SQL — databases;
Rust — systems thinking, memory safety, and performance.

Next, we plan to develop Data Science, Machine Learning, and other directions. But we don’t want to turn this into a race for the number of courses. One complete path where a person actually reaches a working project is better than ten catalogs with five introductory lessons each.

So we will build Rust gradually too — from the first program:

fn main() {
    println!("Hello, world!");
}

to the moment when this short program stops feeling like the main achievement. Something else will become the main thing: you look at a program, understand who owns the data, why the compiler allows some actions and forbids others, and can solve a problem on your own.

That, for us, is where knowledge of a language begins.

View free courses on
Shanraq.org

If you want to learn Rust from scratch, join the first readers. And if you already work with Rust — we would be grateful for feedback on the course program and examples.

Sources

SEO title: Rust from Scratch — free course for beginners |
Shanraq.org

Meta description: Free Rust course for beginners: installation,
Cargo, types, ownership, borrowing, structs, Result, traits, lifetimes,
and concurrency. Learn from scratch at your own pace.

Slug: rust-s-nulya-besplatnyi-kurs