What’s so great about Rust, then? It’s a fair question, and one that can be surprisingly difficult to answer—at least, when someone puts you on the spot. It’s a bit like suddenly being asked “Why do you love your wife?”. If you feel a little tongue-tied, it’s not because you can’t think of any good answers. Rather, so many reasons may come to mind that you’re not sure what to say first.

And when people ask me “Why Rust?” I know it’s not out of skepticism, but from genuine curiosity. They haven’t yet heard a clear signal through all the noise. They’re really asking “What makes Rust special, and why should I care?”

I’ll try to answer that without tripping over my tongue, or sounding like a shiny-eyed cult member. And when we’re done, if you’re not interested in accepting Rust as your personal saviour, I want you to know that I am okay with that. Go in peace, my friend. Be well.

But first, hear me out.

The core value proposition

Rust is a truly excellent programming language. Perhaps the best we have, by any reasonable definition: powerful, portable, and productive.

It’s modern enough to incorporate the lessons we’ve learned from eighty-odd years of software engineering. Yet it doesn’t spend too many innovation tokens: Rust is founded on solid, well-proven principles that have worked in other languages for decades.

Correctness and safety

Rust leans hard into helping us write correct programs, catching as many problems as possible at compile time, and catching any that remain at run time.

Not all software is safety-critical, but when lives really are at stake—in medical, industrial, military, automotive, and aerospace applications—we need a language that puts reliability front and centre.

Here’s what that looks like in practice:

Memory safety. Rust automatically eliminates many of the correctness and security problems that plague other languages, such as buffer overflows.

Data safety. Rust prevents accidental corruption or mutation of data by making sure that only one program thread or task at a time can have write access to values, preventing data races and other mutability issues.

Referential safety. Rust guarantees that references to data will always be valid, with extensive compile-time checking: null pointers can’t exist in Rust, removing a common source of bugs and crashes.

If this doesn’t mean much to you yet, don’t worry. You don’t need to be a computer science guru to get the benefit of Rust’s safety features. Long story short, Rust protects the programmer by making invalid states unrepresentable.

Low-level control and performance

Safety is great, but it’s nothing without control. Critical software such as OS kernels and drivers, or real-time and high-frequency systems, need unfettered access to the underlying hardware.

This is where Rust really shines, providing:

Hardware-level access to memory and registers. Rust supports you, but it doesn’t get in your way. When every byte and nanosecond counts, you have full control of the machine.

Ability to target CPU and GPU-specific features. With broad architecture support, conditional compilation, and inline assembly language, your Rust programs can get the most from modern hardware.

Controlled bypass of safety checks. Rust lets you temporarily disable the guardrails for only those sections of code where it’s necessary. A special keyword identifies these “manual override” sections, reducing the attack surface for potential bugs and vulnerabilities.

Fast, predictable performance. Rust compiles to native machine code, giving you the speed and efficiency of C++ or hand-tuned assembler. Rust doesn’t need a garbage collector, so there’s no memory reclamation overhead and no stop-the-world pauses.

Interoperability with C/C++. Rust programs can talk directly to kernel or SDK code written in C, C++, or any other language, using Rust’s excellent Foreign Function Interface (FFI) support. You can call C libraries from Rust, or mix and match C++ components with Rust packages.

Overall, Rust sits neatly in the “best of both worlds” space between garbage-collected memory-safe languages like Go, and high-performance, close-to-the-metal languages like C++.

Happy, productive developers

Okay, Rust sounds good on the technical side, but what’s it like to use in practice? Well, Rust routinely tops polls of the world’s most-loved languages, so I think the answer must be “pretty great”. Here are a few reasons why:

Super-helpful compiler. The Rust compiler is not only smart and efficient, it has amazing error messages: not just what’s wrong, but why it’s wrong, and what you need to do to fix it.

Powerful build system. The Cargo tool manages your dependencies, runs your tests, builds your code, generates your documentation, and publishes your package to Rust’s open-source repository.

Smart code advisor. Clippy, the Rust linter, not only warns you about problematic code, it even suggests safer, faster, or more idiomatic alternatives.

Rich, expressive language. Rust gives programmers powerful, state-of-the-art tools for problem-solving: iterators, threads, closures, pattern-matching, sum types, generics, async, and traits.

Peace of mind. If your Rust program compiles, it probably works. No more stressing about hidden bugs, or whether your code will blow up in production.

Rust adoption is growing rapidly across the entire tech industry, making Rust a logical pick for businesses today:

Future-proof investment. Rust is a smart and forward-looking choice: there are millions of Rust users and the community is growing all the time. Rust is stable and mature today, and it’ll be around for decades to come; that makes it a reliable long-term bet for your technology stack.

Gradual migration. You don’t have to throw away your existing codebases. Rust has great interoperability with C, C++, and Java-based languages, as well as Python, meaning that you can adopt Rust gradually into your products, component by component, service by service. Rust supports all modern architectures and operating systems, including WebAssembly for browser-based apps.

For developers looking to build a secure, rewarding career, Rust’s advantages make it a safe bet:

Valuable skill. Even though demand is growing fast, there aren’t yet all that many experienced Rust engineers out there. New jobs are opening up all the time; you’ll have less competition for those vacancies, a wider choice of employers, and better compensation and job security wherever you decide to land.

Covers all the bases. Rust is versatile and used across all kinds of industry sectors and applications. You won’t find yourself siloed by your choice of language; instead, Rust keeps your options open.

Happy developers make for a happy community, and the Rust community has a friendly and welcoming atmosphere. Newbies feel supported, and there’s a creative diversity of opinions and backgrounds. Governance is democratic and by consent; Rust is owned by its users, and no big-tech company can take it over or slap a licence fee on it.

Rust programmers take documentation seriously: the language has great facilities for writing detailed hypertext docs with live, interactive examples, Rust itself has all the docs you’ll ever need, and most Rust crates are incredibly well-documented. After all, Rustaceans know that it doesn’t matter how great your software is if no one can figure out how to use it.

Meets you where you are

Rust is attracting developers from all kinds of different backgrounds and language communities, including complete beginners. Here’s what Rust looks like from each of these perspectives:

For beginners, it’s a great first language. Not only will Rust teach you most of the important software concepts that apply to all languages, it’ll also help you build a safe, thoughtful, and disciplined approach to programming.

For C/C++ programmers, Rust offers safety plus interoperability. You get the high-level abstractions and low-level control you’re used to, but without the paperwork. Rust takes over the burden of memory management and correctness checks, and provides seamless integration with existing C/C++ libraries and apps.

For Python users, Rust brings amazing performance. There’s no interpreter or VM overhead, so Rust programs run at the native speed of the hardware. Give your Python codebase a speed boost by using Rust to implement Python modules, or build on your existing investment by calling into Python libraries from your Rust programs.

For embedded developers, Rust provides low-level control with zero dependencies. It’s no surprise, given its strong focus on correctness, that Rust is now a key component of Linux, Windows, iOS, macOS, Android, and other operating systems. It’s also ideal for constrained environments like microcontrollers and embedded devices: Rust can produce bare-metal binaries needing no runtime, no operating system, and no SDK.

Learn once, use everywhere

Good engineers are T-shaped, as the saying goes: they have a broad knowledge of different technologies, but they also have deep expertise with at least one. So, which language should you spend your valuable time on really mastering?

Rust is:

versatile enough to write every kind of software

mature enough to have world-class tools and libraries available

modern enough that your Rust skills will be valuable for decades to come

Yet it’s really not so radically different to the languages you already know. Take your existing software design and problem-solving skills and bring them to Rust; you’ll find everything works just the way you’d expect.

From Rust, with love

Ultimately, software engineering is not just a job, it’s a craft, where if you bring care and skill to what you do, you’ll get satisfaction and fulfilment in return.

For me, Rust is more than just a tool. Learning Rust is stimulating, writing Rust is liberating, and teaching Rust is rewarding. I’ll let the technical arguments speak for themselves, but in the end perhaps the most persuasive reason I can offer you for considering Rust is this:

• There must be something special about a language that so many people fall in love with. And maybe love doesn’t always need a reason.