Rust Guide: Memory Safety, Tooling, and Systems Performance

The compiler is going to argue with you, and a lot of the time it is going to be right. That can be annoying when you are learning the language. It is also the whole reason people put up with the learning curve. Rust moves many memory, ownership, and state mistakes from "maybe production will tell us" into "the compiler will not let this build."

Rust is a systems programming language built around explicit ownership, memory safety, and predictable performance. It gives you low-level control without a garbage collector. The tradeoff is that the language asks you to say who owns a value, who can borrow it, what errors can happen, and what states are allowed.

This Rust track gives developers practical explanations. You should come away knowing why the compiler objected, what design choice it is asking you to make, and how to write code that is safe without turning every function signature into a small legal document.

What Is Rust, in Plain Words?

Rust is a language for software that sits close to the machine, such as servers, command-line tools and pieces of operating systems. The Rust Core Team announced version 1.0 on 15 May 2015 and described a language with low-level control, high-level convenience and safety guarantees, achieved without a garbage collector or runtime. The Rust home page today pitches three things: performance, reliability and productivity.

Picture a building inspector who signs off before anyone pours the concrete. A city that only inspects after the roof caves in learns the lesson the expensive way. In Rust, the compiler is that early inspector, checking how your program uses memory and threads before it ever runs. It refuses to build code that breaks the rules.

Four terms come up everywhere on this page:

• Compiler: the program that turns your Rust code into a program the computer can run, and that explains what it dislikes.
• Ownership: the rule that every value has one owner, and the value is cleaned up when that owner goes away.
• Crate: one unit of Rust code, either your own program or a library someone published.
• Cargo: Rust's build tool and package manager, which runs your code and fetches crates.

Nothing below assumes you know another language, though the compiler will make more sense if you have written a little code somewhere.

Where Rust Fits

Rust is strongest when correctness, performance, and resource control all matter at the same time. That includes command-line tools, infrastructure services, parsers, compilers, embedded systems, edge components, performance-sensitive libraries, and backend services where predictable memory use matters.

It is also useful when you are replacing unsafe or fragile low-level code. Rust will not make the design good automatically, but it removes whole classes of memory bugs when you stay inside safe Rust. Buffer overflows, use-after-free bugs, dangling references, and data races become much harder to ship.

If you need a small script, Python will usually get you there faster. If you need a straightforward operational service, Go may feel lighter. Rust earns its keep when you want the machine-level control and you are willing to make the invariants explicit.

Who Should Learn Rust?

The Rust project interviewed developers for its Vision Doc work and wrote up what it heard about learning in June 2026. One theme stood out: the hard part for experienced programmers was unlearning habits from other languages, and syntax barely came up. That finding shapes who the language suits best:

• New to programming: possible, and one interviewee reported that a person with little prior programming got going fine. That is a single story, so treat it as a lead.
• Coming from Python or JavaScript: you gain speed and compile-time checks, and you take on ownership, which has no equivalent in either language.
• Coming from C or C++: ownership replaces manual freeing, and the object-oriented habits are the part to unlearn.
• Doing data science or machine learning: stay with Python, and use Rust for the fast parts underneath if you ever need to.

What Do People Build with Rust, and Who Uses It?

The Rust home page lists four areas: command-line tools, WebAssembly, network services and embedded devices. Real companies have gone further than that list, and this table shows what each one said in its own words. The dates matter, because some of these posts are several years old.

Who	Used Rust for	Source and year
Google (Android)	New low-level platform code	Security blog, 2025
AWS	Firecracker, S3 and EC2 services	AWS blog, 2020
Cloudflare	Pingora proxy	Company blog, 2022
Discord	Read States service	Company blog, 2020
Dropbox	File sync engine	Company blog, 2020
OpenAI	Codex command-line tool	GitHub discussion, 2025
Linux kernel	Rust support and documentation	Kernel docs, checked 2026

Google reported in November 2025 that Android had roughly five million lines of Rust. By its estimate, memory safety vulnerability density in that code is more than 1000 times lower than in Android's C and C++, and larger Rust changes had a rollback rate about four times lower. Cloudflare wrote in 2022 that its Rust proxy, Pingora, serves over one trillion requests a day on a third of the CPU and memory of the proxy it replaced.

AWS wrote in 2020 that Firecracker, the technology behind Lambda, is built in Rust, and that S3, EC2 and CloudFront services also use it. Dropbox wrote in 2020 that Rust was a force multiplier for its sync engine because its focus on correctness helped tame complexity. The Linux kernel's own documentation now has a Rust section with a quick start guide.

The reasons repeat: memory safety without a collector, speed you can predict, and fewer production surprises. They are good reasons, and they only matter when your project needs them.

How Did Rust Start, and Where Is It Now?

The history matters here because it explains why old advice looks odd.

• Rust 1.0 shipped on 15 May 2015 with a promise that code written for it keeps working, which the Edition Guide calls stability without stagnation. A new release has arrived every six weeks since, so articles go stale quickly.
• Editions are opt-in bundles of language changes. Rust 2018 arrived with Rust 1.31 and Rust 2021 with 1.56. A tutorial full of extern crate lines comes from before 2018.
• Rust 2024 became stable with Rust 1.85 on 20 February 2025, alongside async closures. New projects from cargo new use it by default.
• Rust 1.88 (June 2025) added let chains, which only work in the 2024 edition. Rust 1.95 (April 2026) added if let guards in match arms.
• Rust 1.99 arrived on 1 October 2026 and is the current stable release.

Is Rust Popular, and Is It Growing?

Yes, by the broadest measure. The Stack Overflow Developer Survey asked the same question in 2024 and 2025, and every language below gained ground among respondents.

Language	Used in 2025	Used in 2024
Python	57.9%	51%
TypeScript	43.6%	38.5%
Go	16.4%	13.5%
Rust	14.8%	12.6%

That table covers survey respondents only, and the respondent mix changes from year to year. On a different measure the 2025 survey called Rust the most admired language yet again, at 72%, meaning people who used it want to keep using it. It also named Cargo the most admired tool in its cloud and infrastructure group, at 71%, and the Rust web framework Axum the second most admired web framework, at 76%.

The Rust project's own 2025 survey drew 7,156 completed responses and described a hiring trend of organizations looking for more Rust developers. It also recorded worries that the language keeps getting more complex, and slow compile times and storage use remain among the most reported problems. So Rust is growing and well liked, and it is also demanding.

Is Rust Hard to Learn, and Do Agents Change That?

It is demanding at the start, because ownership feels strange the first time. The Rust Vision Doc post on learning, published in June 2026, quotes one learner who read the Rust Book's borrowing chapter twice and then watched a video. Several said it only clicked after they wrote a lot of Rust, and one engineer said the stack of books and exercises they used was "not a one-pass reading."

Experienced Rust developers gave that post the same advice again and again: clone freely while you are learning, and optimize later. One researcher described weaving lifetimes through a whole project to avoid a single clone, and then watched someone else clone the struct without any harm. The post also found the compiler's messages taught several people about lifetimes before any documentation did.

On AI agents, the same post says interviewees used AI chat tools as a search engine and an example generator, and the Rust team writes that it does not yet know what to make of them as a learning tool. The 2025 Stack Overflow survey reported 84% of respondents using or planning to use AI tools, with 46% distrusting the accuracy and 33% trusting it.

So the skill that pays off is reading. Let an assistant draft, then check how it handles ownership and every Result. The compiler acts as a second reviewer that rejects whole classes of mistakes, and that is why Rust suits agent-written code. It cannot tell you whether the design is right, so that part stays with you.

Should I Use Rust or Go for This Project?

Ask what the project will punish you for. A service that must ship this quarter, read by a whole team, points to Go. A program where memory use or response time has to stay predictable, or where the code sits close to the operating system, points to Rust, and it is worth the extra learning time.

You care about	Rust	Go
Time to first service	Slower, ownership comes first	Quick, small language
Memory and latency	You decide, with no collector	Collector decides, simpler code
Threads and async	Powerful, with a steeper climb	Goroutines built in
Team onboarding	Stricter, more concepts	Gentler, fewer concepts
Deploying	One program file	One program file

OpenAI is a recent example of choosing Rust on purpose. It announced in May 2025 that it was rewriting its Codex command-line tool from TypeScript into Rust, and it cited an install with no Node dependency, native security bindings, no garbage collector and an extensible protocol. GitHub's language statistics now list Rust as roughly 97% of that repository's code.

Go has plenty of loyal users as well, since the Go team's 2025 survey reported 91% of respondents satisfied with it. Discord wrote in 2020 that it moved one latency-sensitive service from Go to Rust because of garbage collection pauses, and that post predates Go's newer collector, so measure your own service before you rewrite anything.

Can I Use Rust on the Backend?

You can, and plenty of companies do. The Rust home page lists network services as a core area, and Cloudflare, Discord and AWS each describe production services written in it. Axum, a web framework from the Tokio project, was the second most admired web framework in the 2025 Stack Overflow survey. Nothing about the language stops you from building an API.

The question is whether you should, and that depends on the job. Async Rust is the hardest corner of the language, and the Rust project's interviews found that beginners often ignore it while learning. Compile times and onboarding cost are real, too. A team that knows TypeScript, Python or Go can ship a plain forms-and-database backend faster in those languages.

DHH, the creator of Ruby on Rails, makes a pragmatic version of this point on his own blog. In 2023 he wrote that when one screen sees wild load spikes and cannot be cached, you might "pull out Rust or Go or whatever to squeeze all the juice out of your CPU." In 2024 he wrote that he would not be a happy camper programming Rust all day, though he loves many tools that community makes. That is one developer's taste, and it points to a sound habit: keep most of the app in a productive language, and reach for Rust at the hot spot.

Is Rust Only for CLI Tools?

No, though command-line tools are a sweet spot. The Rust site lists four areas, and the project's users run well beyond them: Android's platform code, a sync engine at Dropbox, AWS virtualization, and the Linux kernel's documented Rust support. Codex CLI is the best-known recent command-line example, and it moved to Rust partly because Rust builds a program with nothing else to install.

Rust also compiles to WebAssembly, which lets you run it inside a web page, and it reaches down to embedded devices. Learners called the embedded route harder in the Rust project's own interviews, so treat it as a later step.

Rust, Go, Python or TypeScript for Common Jobs?

This table is my call for a beginner choosing a first tool for a job, based on what the official sources say each language is for. Plenty of teams mix them, and no single language lands anyone a job.

Job	Start with	Why
Command-line tool to share	Rust or Go	One file, no runtime to install
Performance-critical core	Rust	No collector, tight control
Embedded or low-level code	Rust	Runs without a runtime
JSON API for a product	TypeScript, Go or Rust	Match your team's skills
Data analysis and AI work	Python	That is where the libraries live
Website front end	TypeScript or JavaScript	Browsers run them natively
Quick automation script	Python	Fastest from idea to result
First phone app	Swift or Kotlin	Native to the platform

Mixing languages is normal on real teams. A Rust service often sits behind a TypeScript front end, and a Python script often prepares the data it reads. Pick the language that fits the job in front of you, and let the next job pick again.

What Rule Does the Rest of Rust Depend On?

Every value in Rust has exactly one owner, and most of the rest of Rust leans on that. The Rust Book says the value is dropped when the owner goes out of scope. The program below gives a piece of text a second name and then tries to use the first one.

fn main() {
    let title = String::from("Quarterly report");
    let backup = title;
    println!("{title} and {backup}");
}

# Compiler output (trimmed):
error[E0382]: borrow of moved value: `title`
 --> src/main.rs:4:16
  |
2 |     let title = String::from("Quarterly report");
  |         ----- move occurs because `title` has type `String`, which does not implement the `Copy` trait
3 |     let backup = title;
  |                  ----- value moved here
4 |     println!("{title} and {backup}");
  |                ^^^^^ value borrowed here after move

Handing the text to backup moved ownership, so title stopped working. The compiler points at each step and even suggests copying the value instead. Borrowing, lifetimes and smart pointers are all answers to the same question: how do two parts of a program use one value safely? Learning to answer that question is most of what learning Rust means.

What Changed in Rust Recently?

Rust ships a new version every six weeks, so the list below stays short and sticks to what a learner will meet. If the schedule holds, the next release is due in mid-November, and the beta channel already carries 1.100.

• Rust 1.85 (February 2025): the 2024 edition became stable, along with async closures.
• Rust 1.88 (June 2025): let chains, which let one if test several patterns, in the 2024 edition only.
• Rust 1.95 (April 2026): if let guards on match arms, and a cfg_select! macro for compile-time choices.
• Rust 1.96 (May 2026): new range types that can be copied, and assert_matches! for tests.
• Rust 1.97 (July 2026): Cargo can control whether warnings fail a build, and the newer symbol mangling scheme became the default.
• Rust 1.99 (October 2026): C-style variadic function definitions and a handful of new library methods, with nothing a beginner must learn.

The Rust Book now assumes Rust 1.90 or later with the 2024 edition, so its examples match what cargo new gives you today. The Rust blog also reported supply-chain attacks and a leaked-secrets problem in 2026, so check what your own dependencies pull in. Check the Rust 1.99.0 announcement for the official summary.

Learning Path

Learn Rust in the order that makes the borrow checker stop feeling like an enemy:

1. Ownership and moves, so you know who is responsible for each value.
2. Borrowing with & and &mut, and the one-mutable-or-many-shared rule.
3. Structs and enums for modeling data, then match for handling every case.
4. Result and the ? operator for errors you can recover from.
5. Vec, String, and HashMap, plus iterator chains with map and filter.
6. Traits and generic bounds once you want to share behavior across types.
7. Cargo, crates, and tests as the everyday workflow.
8. Async Rust and an executor like Tokio when the work is IO-bound.

Once ownership and errors feel routine, go build something small and real. A command-line tool that reads a file, parses it, and prints a summary will teach you ownership, errors, and iterators without a framework in the way.

When Are You Ready for the Next Step?

The eight steps above, with language basics added at the front and a language-choice step at the end, make a nine-step path. Install Rust before you start step one. Read structs and enums early, and save traits and generics for after collections and iterators.

Step	Move on when you can
1. Language basics	Write a small program with loops
2. Ownership	Explain why a value was moved
3. Types	Model data with a struct and enum
4. Errors	Return a Result and use ?
5. Collections	Store items in a Vec and a HashMap
6. Iterators	Swap an index loop for map and filter
7. Cargo and testing	Run cargo test and cargo clippy
8. Concurrency	Spawn a thread and share data safely
9. Choosing a language	Pick Rust or another language

What Mistakes Do Beginners Make in Rust?

The first row is a compiler error, and the others come from the Rust Book, the Cargo reference and the Rust project's learning research. Most of them are the compiler protecting you, which feels better once you know it is on your side.

Mistake	What happens	Fix
Using a value after moving it	Error E0382, value moved	Borrow it or clone it
Avoiding every clone	Lifetime errors eat hours	Clone freely while learning
Writing inheritance-style objects	Rust has no inheritance	Use structs, enums, traits
Calling unwrap everywhere	Panics on None or Err	Return a Result instead
Timing a debug build	Unoptimized, so it looks slow	Time with --release
Starting with async	Hard concepts arrive too early	Learn ownership first
Following pre-2018 tutorials	extern crate lines, old patterns	Check the edition year
Treating unsafe as checks off	Only five extra operations	Keep unsafe small and reviewed

Two of those cost beginners the most time. Fighting the borrow checker with clever references, when a clone would have been fine, is the slow one. Writing Java-style or C++-style objects is the sneaky one, because the code looks reasonable until the compiler refuses it.

What Should I Learn First?

If you only have an evening, do this in order and skip everything else for now:

1. Install Rust through rustup and run cargo new followed by cargo run, following the install steps on rust-lang.org.
2. Write a small program with variables, a loop, and one function that returns a value.
3. Make one value move on purpose and read the compiler's message from top to bottom.
4. Clone when the borrow checker fights you, and clean it up later.
5. Return a Result from a function and handle it with ?.
6. Leave traits, lifetimes and async until the earlier steps feel ordinary.

Go slowly through ownership now, and everything after it moves faster.

What to Build First

Build a small command-line tool with real input and real failure paths. A log filter or a word-count utility is enough if you treat it seriously: take a file path as an argument, return a Result from each fallible step, use ? to bubble errors, and shape the output with an iterator chain.

Hold yourself to this checklist while you write it:

• Decide who owns each value, and borrow with & instead of cloning by reflex.
• Return Result from anything that can fail, and handle the error at the edge.
• Model the data with a struct or enum before you reach for loose tuples.
• Replace index loops with iterator methods where they read more clearly.
• Run cargo fmt, cargo clippy, and cargo test before you trust the code.
• Get a second version from an AI assistant, then read how it handles ownership and Result.

When that feels ordinary, the bigger Rust patterns stop looking like ceremony and start looking like the compiler helping you keep promises you already wanted to keep.

What Can't Rust Do?

Rust solves a specific set of problems, and it leaves others alone. Here are the limits that matter most:

• Make builds instant: the project's 2025 survey lists slow compile times and storage use among the most reported problems.
• Fix a bad design: the compiler checks memory and thread safety, and it has no opinion on whether your program does the right thing.
• Catch every bug: safe Rust still allows memory leaks, such as reference cycles, and logic errors that no compiler can see.
• Replace a quick script: Python gets a small job done faster, and a first mobile app belongs in Swift or Kotlin.
• Skip the learning curve: ownership takes practice, and the project's own interviews say it clicks after a lot of code.

Rust can work as a first language if you are patient and your goal needs what Rust offers. If you want quick wins and fast feedback, start elsewhere, and come back once you have a reason to.

Related Languages

Rust is the right starting point when memory safety and performance both matter and you are willing to make ownership explicit. The ownership model is the part that feels new, and it is worth the adjustment.

Reach for Python when scripts and data work matter more than control over memory. Go is the lighter option for operational services that value quick iteration. Swift shares Rust's value-type instincts in a more app-focused setting, and C# fits teams already on .NET. Many systems teams keep Rust for the performance-critical core and a higher-level language for the glue.

Related

• Go - a lighter language for operational backend services.
• Swift - value-type-first design for Apple platforms.
• Programming - the broader language and data-structure index.
• Backend development - how servers, APIs and databases fit together in any language.
• APIs - the request, response and status-code ideas a Rust service speaks.
• DevOps - the wider picture of building, shipping and running programs.

Frequently Asked Questions

What does fearless concurrency mean?

That the ownership and borrowing rules catch data races at compile time rather than in production. Multithreaded code which compiles has already been checked for the shared-mutable-state bugs that cause corruption in languages without that guarantee.

Can Rust code still leak memory?

Yes, it can, because safe Rust prevents use-after-free, buffer overflows, and dangling references, but a reference cycle built with Rc or Arc leaks perfectly safely, because nothing frees data that still has a live reference pointing at it.

What is unsafe Rust?

A keyword that unlocks five extra operations the compiler cannot verify, such as dereferencing raw pointers and calling C functions. It does not turn off the borrow checker or Rust's other safety checks, so you take on responsibility only for those five operations. Idiomatic Rust keeps unsafe code in a small, carefully reviewed boundary rather than spreading it.

Does Rust have null?

Rust has no null pointer, so a value that may be absent is wrapped in Option, and the compiler will not let code use it without handling the None case, which removes null dereferencing as a category of runtime failure.

Can Rust call C libraries?

Yes, through its foreign function interface, where an extern C block declares the signatures, and since the 2024 edition that block must itself be written as unsafe extern. Rust can also expose its own functions for C to call in return, which is how it integrates into existing C and C++ codebases.

Is Rust harder than Go?

Usually yes at the start, because ownership and borrowing add ideas that Go does not have. The Rust project's learning research heard the same story repeatedly: it clicks after a lot of code, and the compiler's messages do much of the teaching. Go usually reaches a first working program faster.

Should I learn Rust or Go first?

Learn Go first if you want working programs quickly, because it has fewer concepts to absorb. Learn Rust first only when memory control or having no garbage collector is the point of your project. Many people learn Go first and add Rust later when a project calls for it.

Is Rust still growing?

Yes, going by the Stack Overflow Developer Survey, where Rust use among respondents rose from 12.6% in 2024 to 14.8% in 2025. The same survey called it the most admired language at 72%, and the Rust project's own survey described organizations hiring more Rust developers.

Is Rust good for web development?

For the server side, yes, because the Rust home page lists network services as a core area, and Axum, from the Tokio project, was the second most admired web framework in the 2025 Stack Overflow survey. In the browser, Rust compiles to WebAssembly, though front ends remain mostly JavaScript and TypeScript territory.

Which Rust version should I install?

Install the current stable release through rustup. Rust 1.99.0 came out on 1 October 2026, and new projects from cargo new use the 2024 edition by default. A new stable version arrives every six weeks, and rustup update installs it.

What is a Rust edition?

An edition is an opt-in bundle of language changes that may break old code, so existing crates keep working until you migrate. Rust 2024 is the latest edition, stable since Rust 1.85 in February 2025, and crates on different editions work together.

Where to Start

Install Rust with rustup, run cargo new, and make one value move on purpose so you can read the compiler's message. Then work down the learning path above, starting with ownership. Build the small command-line tool afterwards, because Rust sticks once you have fought it on your own code.