Rust vs C++, Go, and Python

“Should I learn Rust, or Go, or stay with Python?” is one of the most common questions people ask when they discover Rust. The honest answer is: it depends on what you want to build. Every language on this page is a good language, used by millions of people. Each one made different trade-offs.

Think of languages like vehicles. A sports car, a delivery van, and a bicycle are all “good”. You just wouldn’t use a bicycle to move furniture. This page explains the trade-offs in plain words, so you can pick the right tool for your job. We’ll try hard to be fair, including about Rust’s weak points.

What Rust is good at

Rust’s main promise is speed and safety at the same time:

• Fast, like C and C++. Rust compiles to native machine code and has no garbage collector, so there are no pauses while memory is cleaned up.
• Memory safe without a garbage collector. The ownership and borrowing rules are checked when you compile. Whole groups of bugs (using freed memory, data races between threads) are rejected before the program ever runs.
• Great tooling out of the box. One tool, Cargo, builds your code, downloads libraries, runs tests, and generates documentation. The formatter (rustfmt) and linter (clippy) are official.
• Helpful compiler errors. The compiler often tells you exactly how to fix the problem.

Developers seem to enjoy it, too: in the 2025 Stack Overflow Developer Survey, Rust was again the “most admired” programming language, meaning most people who use it want to keep using it.

The same task in four languages

Let’s start with something small: add up the even numbers in a list. Here it is in Rust:

fn main() {
    let numbers = vec![1, 2, 3, 4, 5, 6];
    let sum: i32 = numbers.iter().filter(|n| *n % 2 == 0).sum();
    println!("Sum of even numbers: {sum}");
}

Output:

Sum of even numbers: 12

▶ Try it Yourself

The same program in C++:

#include <iostream>
#include <vector>

int main() {
    std::vector<int> numbers = {1, 2, 3, 4, 5, 6};
    int sum = 0;
    for (int n : numbers) {
        if (n % 2 == 0) {
            sum += n;
        }
    }
    std::cout << "Sum of even numbers: " << sum << "\n";
}

In Go:

package main

import "fmt"

func main() {
  numbers := []int{1, 2, 3, 4, 5, 6}
  sum := 0
  for _, n := range numbers {
    if n%2 == 0 {
      sum += n
    }
  }
  fmt.Println("Sum of even numbers:", sum)
}

And in Python:

numbers = [1, 2, 3, 4, 5, 6]
total = sum(n for n in numbers if n % 2 == 0)
print("Sum of even numbers:", total)

All four print the same line. Python is the shortest, Go and C++ use a plain loop, and Rust uses an iterator chain with a closure (you could also write a for loop in Rust). For small programs like this, the differences are mostly about style. The real differences show up in bigger programs.

Rust vs C++

C++ and Rust aim at the same space: fast programs with full control over memory, like browsers, game engines, databases, and operating systems. The big difference is who checks that memory is used correctly.

In C++, it’s you. Here is a classic bug. A C++ compiler accepts this code without complaint, but push_back may move the vector to new memory, so first can point at memory that was already freed:

std::vector<int> v = {1, 2, 3};
int& first = v[0];
v.push_back(4);              // may move the vector's memory...
std::cout << first << "\n";  // ...so this can read freed memory

The same mistake in Rust doesn’t compile:

fn main() {
    let mut v = vec![1, 2, 3];
    let first = &v[0];
    v.push(4);
    println!("{first}");
}

error[E0502]: cannot borrow `v` as mutable because it is also borrowed as immutable
 --> src/main.rs:4:5
  |
3 |     let first = &v[0];
  |                  - immutable borrow occurs here
4 |     v.push(4);
  |     ^^^^^^^^^ mutable borrow occurs here
5 |     println!("{first}");
  |                ----- immutable borrow later used here

This matters a lot in practice. The Chromium team reports that around 70% of their serious security bugs are memory safety problems. Google’s Android team has written new code in Rust for several years. They reported zero memory safety vulnerabilities found in Android’s Rust code in 2022, and in 2025 a more than 1000x lower memory safety vulnerability density than in their C and C++ code. The Linux kernel also supports code written in Rust.

Tooling: C++ has many build systems and package managers, and teams often spend real time on setup. Rust has one standard tool, Cargo, so every Rust project builds the same way.

Learning curve: both are hard. C++ is huge, and many of its rules are learned by making mistakes at runtime. Rust’s rules are strict, but the compiler enforces them and explains them, so you learn them at compile time.

Where C++ still wins: decades of existing code, libraries, and experienced developers. If your company or your game engine is built on C++, C++ is often the practical choice. Rust can call C code, and C++ through C-style interfaces, but mixing them takes effort.

Rust vs Go

Go and Rust are often compared because both are modern, compiled, and popular for servers and command-line tools. But they were designed with different goals.

Garbage collection vs ownership. Go uses a garbage collector that finds and frees unused memory while your program runs. That makes Go code simpler to write: you never think about who owns a value. The cost is some extra memory and CPU, and short pauses. Rust has no garbage collector. Memory is freed at a known point, when the owner goes out of scope. That gives more predictable performance, but you must learn ownership and borrowing.

Concurrency. Go’s goroutines and channels are famous for being easy. Here is a small example that squares three numbers in parallel and adds them up:

results := make(chan int)

for n := 1; n <= 3; n++ {
  go func() {
    results <- n * n
  }()
}

total := 0
for i := 0; i < 3; i++ {
  total += <-results
}
fmt.Println("total:", total)

The Rust version uses threads and a channel. It is a little more verbose: you clone the sender for each thread and use move:

use std::sync::mpsc;
use std::thread;

fn main() {
    let (tx, rx) = mpsc::channel();

    for n in 1..=3 {
        let tx = tx.clone();
        thread::spawn(move || {
            tx.send(n * n).unwrap();
        });
    }
    drop(tx); // close our copy so the loop below can end

    let total: i32 = rx.iter().sum();
    println!("total: {total}");
}

Output:

total: 14

▶ Try it Yourself

What you get for that extra typing: Rust refuses to compile code where two threads could change the same data at once (a data race). In Go, data races are possible; Go provides a race detector that finds them while the program runs. See Concurrency for more.

Compile times. Go was built to compile fast. Its FAQ says it should take at most a few seconds to build a large executable. Rust compiles more slowly, because the compiler does much more checking and optimizing. You’ll notice this on big projects.

Simplicity. Go is deliberately a small language, with few features to learn, so many people find they can read Go code quickly. Rust has more features (traits, generics, lifetimes, macros), which give more power but take longer to learn.

Rust vs Python

Python and Rust are very different, and they are often used together rather than instead of each other.

Speed. Python is interpreted, so pure Python code that does a lot of computing is much slower than compiled code. That’s why popular Python libraries often do their heavy work in C, C++, or Rust underneath.

Typing. In Python, types are checked while the program runs. This function works for a number and fails for a string, but you only find out when that line runs:

def add_tax(price):
    return price * 1.2

print(add_tax(10))    # 12.0
print(add_tax("10"))  # TypeError: can't multiply sequence by non-int of type 'float'

Python has optional type hints, but the Python runtime does not enforce them. In Rust, every type is checked before the program runs:

fn add_tax(price: f64) -> f64 {
    price * 1.2
}

fn main() {
    println!("{}", add_tax(10.0));
    println!("{}", add_tax("10"));
}

error[E0308]: mismatched types
 --> src/main.rs:7:28
  |
7 |     println!("{}", add_tax("10"));
  |                    ------- ^^^^ expected `f64`, found `&str`
  |                    |
  |                    arguments to this function are incorrect

When Python is still the better tool: quick scripts, data analysis, machine learning, notebooks, automation, and teaching beginners. Python’s ecosystem for data science is enormous, and you can try an idea in minutes. If your program spends most of its time waiting for the network or a database, Python’s speed often doesn’t matter.

Using both: the PyO3 project lets you write Python modules in Rust, so you can keep your Python code and move only the slow part to Rust. Some popular Python tools are themselves written in Rust; for example, the Stack Overflow survey notes that the Python package manager uv is built in Rust.

Side-by-side comparison

These are general tendencies, not strict rules. A well-written program in any of these languages can be “fast enough”.

	Rust	C++	Go	Python
Speed	Very fast, native code, no GC	Very fast, native code, no GC	Fast, native code with a GC	Slower for heavy computing in pure Python
Memory safety	Checked at compile time (outside unsafe)	Programmer’s responsibility	GC; data races still possible	GC; safe, but type errors appear at runtime
Learning curve	Steep at first	Steep, and a very large language	Gentle	Gentlest
Compile time	Slow-ish	Slow-ish (depends on the project)	Very fast	No compile step
Ecosystem	Younger, growing; Cargo built in	Huge and mature; many build tools	Strong standard library, great for servers	Enormous, especially data and ML
Typical uses	CLI tools, servers, systems code, WebAssembly, embedded	Games, browsers, high-performance and legacy systems	Web services, cloud and DevOps tools	Scripting, data science, ML, automation

When should you choose Rust?

Ask yourself these questions:

• Do you need top speed or low memory use, for example a game engine, a database, or code on a small device? Rust (or C++) is a strong choice.
• Will bugs be expensive? Security-sensitive code, long-running servers, and code that many people depend on benefit most from Rust’s compile-time checks.
• Are you building a command-line tool you want to share? Rust produces a single fast binary with no runtime to install. Go is also great here.
• Do you need a web service quickly, with a team that is new to all of these languages? Go will probably get you there faster. Rust works well too (see Project: Web API), but the learning time is longer.
• Is it a quick script, data analysis, or an ML experiment? Use Python. Reach for Rust later, through PyO3, if one part becomes too slow.
• Is there a large existing C++ codebase? Stay with C++ for now, or introduce Rust in new, separate parts, like Android did.

And if you just want to become a better programmer: learning Rust teaches you how memory really works, and that knowledge helps in every other language.

Honest downsides of Rust

Rust is not perfect. Here are the things people struggle with most:

• The learning curve is real. The first weeks with the borrow checker can be frustrating. Expect to “fight the compiler” for a while. It gets much easier once ownership clicks.
• Compile times are slower than Go’s, especially for large projects and release builds.
• Some things are harder to express. Graph-like data with many links between objects, or code that shares lots of mutable state, needs tools like smart pointers and takes more planning.
• The ecosystem is younger. For some areas (GUI apps, certain scientific libraries) there are fewer mature options than in C++ or Python.
• Fewer people use it (for now). In the 2025 Stack Overflow survey, far more respondents said they used Python (about 58%) or C++ (about 24%) than Rust (about 15%). That means fewer experienced Rust developers to hire, ask, or learn from at work.
• More code for simple things. As the channel example showed, Rust often asks you to be explicit where other languages are relaxed.

Going further

Coming from C# and .NET? Rust for C# Developers maps classes, LINQ, async, NuGet, Entity Framework and ASP.NET Core to their Rust equivalents.

There are guides like that for other languages too: Rust for Python Developers, Rust for JavaScript and TypeScript Developers, Rust for Java Developers and Rust for Go Developers.

Recap

• Rust gives C++-level speed with memory safety checked at compile time, and has excellent built-in tooling.
• Compared to C++, Rust prevents whole classes of memory bugs before the program runs; C++ has far more existing code and libraries.
• Compared to Go, Rust has no garbage collector and stops data races at compile time; Go is simpler and compiles much faster.
• Compared to Python, Rust is much faster and checks types before running; Python is quicker to write and dominates data science. PyO3 lets you combine them.
• Rust’s main costs are a steep learning curve, slower compiles, and a younger ecosystem.

Quick check

Quick check

1. How does Rust manage memory without a garbage collector?

It never frees memory Through ownership and borrowing rules checked at compile time The operating system cleans up every few seconds You must call free() by hand

2. Which of these is a fair advantage of Go over Rust?

Go prevents all data races at compile time Go has no garbage collector Go is a smaller language and compiles faster Go is always faster at runtime

3. You have a Python program where one function is far too slow. What is a common approach?

Rewrite the whole program in C++ Add more type hints Python can never be sped up Rewrite just that function in Rust and call it from Python with PyO3

4. In the C++ vs Rust example, what happens to the code that keeps &v[0] and then pushes to v?

Rust refuses to compile it Rust compiles it and it crashes at runtime Rust silently copies the vector Both languages reject it

Score: 0 / 4

Read more

• The Rust Programming Language — Introduction: who Rust is for, in the official book’s own words.
• Rust in Android: move fast and fix things — Google Security Blog: real data from a large team using Rust next to C and C++.
• Stack Overflow Developer Survey 2025 — Admired and Desired: how developers feel about Rust, Go, Python, C++, and other languages.
• Go FAQ — Why did you create a new language?: Go’s own design goals, useful for understanding where it shines.
• PyO3 user guide: how to write Python extensions in Rust.