Learning Rust in 2026: why, and what you can build with it
Updated on 16 November 2026. Several projects mentioned here are still in development: their status is stated each time, with a link to the source.
Image: rust-lang.org.
Rust 1.100.0 came out on 12 November 2026 (announcement). A week earlier, Discord's chief technology officer announced that the whole client was being rewritten in Rust. In between, you may well have installed uv, ripgrep or Zed without wondering what language they were written in.
This article is for web developers coming from PHP or JavaScript who are wondering whether Rust is worth the time it takes. It explains what is specific about the language, what people build with it, who really uses it, what is hard, and where to start. Rust is not the right answer for every project, and the last part says when another choice makes more sense.
The short version
- Rust is a compiled language that checks at compile time how your code uses memory, with no garbage collector.
- It is mostly used where performance and control over resources matter: command-line tools, network services, system components, desktop applications.
- For a web developer, the most natural ways in are a small command-line tool and Tauri, which keeps the interface in HTML, CSS and JavaScript.
- Composer is still written in PHP. The Rust tools that reproduce part of what it does are independent projects.
- Learning it is demanding, and the first weeks are largely spent working out why the compiler rejects code that looked correct.
Where Rust comes from
Rust started as a personal project of Graydon Hoare, then a Mozilla employee. The project's blog dates its conception to 2010, as a Mozilla Research project, and adds that you might even say 2006 depending on how you count (Rust Blog). The starting question: how to get the performance and control of systems languages while removing a whole family of memory and concurrency errors.
| Date | Event |
|---|---|
| Around 2006 | Graydon Hoare's first work on the language. |
| 2010 | Rust becomes a Mozilla Research project. |
| 15 May 2015 | Rust 1.0, with a promise of stability and compatibility. |
| August 2020 | Mozilla lays off around 250 people, including active members of the project. The team announces plans for a foundation. |
| 2021 | The Rust Foundation is created. |
| December 2025 | The Linux kernel maintainers drop the "experimental" tag from Rust in the kernel (LWN). |
| 12 November 2026 | Rust 1.100.0. |
What sets it apart
A compiler that checks who owns what
Rust's central idea is called ownership. Every value has exactly one owner at a time. When that owner goes out of scope, the memory is freed, with no garbage collector and no free to write (The Rust Programming Language).
This program does not compile:
fn main() { let names = vec![String::from("Ada"), String::from("Margaret")]; let other = names; // the value is moved into `other` println!("{:?}", names); // rejected: `names` no longer owns anything }
The compiler answers:
error[E0382]: borrow of moved value: `names` --> move.rs:4:22 | 2 | let names = vec![String::from("Ada"), String::from("Margaret")]; | ----- move occurs because `names` has type `Vec<String>`, which does not implement the `Copy` trait 3 | let other = names; // the value is moved into `other` | ----- value moved here 4 | println!("{:?}", names); // rejected: `names` no longer owns anything | ^^^^^ value borrowed here after move | help: consider cloning the value if the performance cost is acceptable
In PHP or JavaScript this code would work: both variables would point to the same array. Rust forbids it because two owners for one value make double frees and use-after-free possible.
The usual fix is borrowing: you lend the value through a reference and keep ownership.
fn show(names: &Vec<String>) { println!("{:?}", names); } fn main() { let names = vec![String::from("Ada"), String::from("Margaret")]; show(&names); // we lend the value, we do not give it away println!("{} names", names.len()); }
The part of the compiler that enforces these rules is the borrow checker. It also checks that a reference does not outlive the value it points to, using lifetimes, and that data is not modified in one place while it is being read in another. That last rule is what prevents a share of data races between threads.
No null, no exceptions
Rust has no null value. A value that may be missing is an Option, and an operation that may fail returns a Result. The compiler makes you handle both cases.
use std::fs; fn read_port(path: &str) -> Result<u16, String> { let content = fs::read_to_string(path) .map_err(|e| format!("cannot read file: {e}"))?; content .trim() .parse::<u16>() .map_err(|e| format!("invalid port: {e}")) } fn main() { match read_port("port.txt") { Ok(port) => println!("Port: {port}"), Err(message) => eprintln!("Error: {message}"), } }
The ? returns the error to the caller if the operation fails. The function signature says it can fail, which a PHP exception does not show.
Tooling that ships with the language
rustup installs and updates the compiler. cargo creates projects, manages dependencies, builds, runs tests and publishes. rustfmt formats the code and clippy points out clumsy constructs. A developer used to Composer or npm finds their bearings quickly with Cargo.toml and cargo add.
What Rust does not guarantee
Rust has an unsafe keyword, which allows operations the compiler cannot verify (documentation). A Rust program can also contain logic errors, vulnerable dependencies or a bad configuration.
Google gives a concrete example. In November 2025, its Android team described a buffer overflow found in unsafe code in CrabbyAVIF, a component written in Rust. The flaw, CVE-2025-48530, was fixed before it reached a public release (Google Security Blog). The same post reports that memory safety vulnerabilities fell below 20% of Android's total vulnerabilities in 2025, and that the density of such flaws is roughly a thousand times lower in Android's Rust code than in its C and C++ code.
Why it gets so much attention
In the 2025 Stack Overflow survey, Rust is the most "admired" language: 72.4% of those who have used it want to keep using it. In the same survey, 14.8% of respondents say they use it (Stack Overflow Developer Survey 2025). The two figures measure different things, and both come from a questionnaire filled in by volunteers.
The Rust community's own survey, published in March 2026, gathered 7,156 responses, and its authors warn against extrapolating too much from that sample. It is useful for another reason: the list of problems reported by users themselves starts with slow compilation, high disk space usage and a subpar debugging experience (2025 State of Rust Survey).
What you can build
Command-line tools
This is where Rust is most visible day to day. ripgrep searches text, fd finds files, bat displays them with syntax highlighting. On the Python side, uv manages projects and packages, and Ruff is a linter and formatter. These tools ship as a single executable, with no runtime to install.
For a PHP developer, a first tool can be very modest. This one lists the packages in the require section of a composer.json:
cargo new composer-check cd composer-check cargo add serde_json
use std::{env, fs, process}; use serde_json::Value; fn main() { let path = env::args().nth(1).unwrap_or_else(|| "composer.json".to_string()); let content = fs::read_to_string(&path).unwrap_or_else(|e| { eprintln!("Cannot read {path}: {e}"); process::exit(1); }); let json: Value = serde_json::from_str(&content).unwrap_or_else(|e| { eprintln!("Invalid JSON in {path}: {e}"); process::exit(1); }); match json["require"].as_object() { Some(packages) => { for (name, constraint) in packages { println!("{name} {}", constraint.as_str().unwrap_or("?")); } } None => println!("No \"require\" section in {path}"), } }
cargo run # php >=8.3 # symfony/console ^7.2
Desktop applications
There are two approaches. The first keeps web technologies. Tauri renders an HTML, CSS and JavaScript interface in the system's webview, and the application logic can be written in Rust. Since it does not bundle a browser engine, its documentation says a minimal app can be less than 600 KB. Any framework that compiles to HTML, CSS and JavaScript works, and Tauri also targets Android and iOS. On mobile, the interface is still a web page shown in a webview and does not use the system's native components.
npm create tauri-app@latest
Image: Tauri.
The second approach draws the interface without HTML. GPUI, the framework created by the team behind the Zed editor, renders directly on the GPU. Zed reached version 1.0 on 29 April 2026 for macOS, Windows and Linux, and its authors say hundreds of thousands of developers rely on it every day (Zed is 1.0). Iced and egui are two other UI libraries, with different choices on rendering, accessibility and platforms.
Image: Zed.
Web services and APIs
Axum and Actix Web are the two most frequently mentioned frameworks, and Tokio provides the async runtime Axum is built on. A minimal service with Axum 0.8:
cargo add axum cargo add tokio --features full
use axum::{routing::get, Router}; #[tokio::main] async fn main() { let app = Router::new().route("/", get(|| async { "Hello from Axum" })); let listener = tokio::net::TcpListener::bind("127.0.0.1:3000") .await .unwrap(); axum::serve(listener, app).await.unwrap(); }
That does not mean an ordinary API should be rewritten. For a business application with forms, a database and an admin area, Symfony, Laravel or Node.js will ship faster with a team that knows them. Rust becomes interesting for one specific service that handles a lot of data or connections, or whose latency has to stay stable.
System components
Android uses Rust in its kernel, in firmware and in several security and networking components, for new code and without systematically rewriting what exists (Google, 2022).
Ubuntu offers a more nuanced example. Since version 25.10, sudo and the core utilities are provided by Rust reimplementations, sudo-rs and uutils coreutils. In its April 2026 update, Canonical reports that two security audits identified 113 issues and led to 45 CVEs. In Ubuntu 26.04 LTS, cp, mv and rm are still provided by GNU coreutils until remaining time-of-check to time-of-use issues are resolved (Ubuntu Discourse). Rewriting a tool in Rust removes one class of errors. Logic errors remain, and compatibility with the original has to be checked case by case.
WebAssembly, mobile and games
Rust compiles to WebAssembly, which lets you move a heavy computation into the browser while keeping JavaScript or TypeScript for the interface (The Rust and WebAssembly Book). Whether it pays off depends on the cost of passing data between the two sides. On mobile, Rust is most often used to share logic between Android and iOS. For games, Bevy is an open-source engine written in Rust.
Discord: a rewrite that is announced, not yet shipped
Discord has used Rust for a long time. In February 2020, the company explained why it had rewritten its "Read States" service in Rust; that service keeps track of which channels and messages each user has read. The Go version suffered latency spikes roughly every two minutes, when the garbage collector scanned a large in-memory cache. The Rust version had no such spikes and did better on latency, CPU and memory (Discord). The company has also described Rust services in its message storage.
On 5 November 2026, Stanislav Vishnevskiy, co-founder and chief technology officer, announced on X that the whole client was moving to Rust: "That means Electron goes away, and so does React Native, mobile keeps native UI but shares app code with desktop via Rust" (The Verge). According to IT-Connect, the desktop interface is built on GPUI, the system webview would still be used for some integrations, and an early Windows build showed 290 MB of RAM with two accounts signed in.
This client is not available. Discord says it hopes to get it into testing with users soon and has given no date. The memory figures come from the company's own demo, on a build that is not finished.
PHP: Composer alternatives written in Rust
Composer, the dependency manager of the PHP ecosystem, is written in PHP and stays that way. It has not been ported to Rust. What does exist is a set of independent projects that reproduce or speed up part of its work.
- Vivacity reimplements five commands:
install,update,require,removeanddump-autoload. The ePHPm tool embeds it, and its documentation is explicit: "ephpm composeris not Composer". Outside those five commands, it hands the work to a real Composer or stops with an error (ePHPm). - Composr targets cold-start installs of Laravel projects. It works in hybrid mode: when a script calls a PHP class method, it delegates that event to the real Composer. Its authors measure, on an application with 292 packages and no caches at all, about 33 seconds against 72 with Composer. That is their measurement, on their project.
- Libretto reads
composer.jsonandcomposer.lock. Its authors describe it as alpha, experimental software that is not a drop-in replacement for Composer, because Composer plugins are PHP code that a Rust program cannot run without an interpreter.
Before using one of them on a real project, check compatibility with your plugins and scripts, and keep Composer as the reference in production.
What it costs
For someone coming from PHP or JavaScript, several concepts are new at the same time: ownership and borrowing, lifetimes, error handling with Result, the constraints on sharing data between threads, and the differences between synchronous and asynchronous code. The compiler rejects code that looks correct, and it takes time before its rejections become predictable. Its messages help, like the one shown above, which points to the offending line and suggests a fix.
Compile times are the first complaint from users in the 2026 survey. Library maturity varies a lot from one domain to another. In a team, training time and hiring difficulty count as much as the qualities of the language.
Rust is probably not the first choice for an ordinary website or business application, for a prototype that has to ship fast, or for a project whose team has nobody who knows it. It complements PHP, JavaScript or Python on specific needs and does not force you to rewrite anything.
Where to start
Installation goes through rustup (official page):
curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh cargo new hello cd hello cargo run
Free resources:
- Comprehensive Rust, the course from Google's Android team. It goes from basic syntax to generics and error handling, with four days for the fundamentals, and assumes you already know how to program. It is available in English, French and Spanish, among other languages. The translations are partial: in the French one, for example, the page on ownership keeps its text in English.
- The Rust Programming Language, the official book.
- Rust by Example to learn from short examples, and Rustlings for exercises you fix in the terminal.
- The Cargo documentation.
A few first projects within reach of a web developer:
- a command-line tool that searches text in a project;
- a program that reads a JSON or CSV file and produces a report;
- a utility that inspects
composer.jsonorpackage.jsonfiles, like the example above; - a small API with Axum;
- a desktop application with Tauri, keeping a web interface.
Sources
The language and its history:
- Rust official website
- Rust Blog: Announcing Rust 1.100.0
- Rust Blog: Laying the foundation for Rust's future
- The Rust Programming Language: ownership and unsafe Rust
- LWN: The (successful) end of the kernel Rust experiment
Surveys:
Projects and companies:
- Discord: Why Discord is switching from Go to Rust
- The Verge: Discord is ditching Electron
- IT-Connect: Discord réécrit son client en Rust (in French)
- Zed is 1.0
- Google: Rust in Android, move fast and fix things
- Ubuntu: An update on rust-coreutils and system utility replacements
- Tauri: What is Tauri?
PHP and Composer:
Written by Jatniel, senior full-stack PHP developer.
