En 2006, un programador de 29 años volvió a su casa en Vancouver y se encontró, otra vez, el ascensor estropeado. Vivía en el piso 21, y pensó que era ridículo que los informáticos no supieran hacer ni un ascensor que funcionara sin colgarse. Poco después empezó a diseñar un lenguaje de programación. Se llamaba Graydon Hoare, y el lenguaje, Rust. Veinte años después está dentro del kernel de Linux, de Android, de Windows y de las herramientas con las que la IA escribe código. Te contamos cómo nació, qué ideas lo hicieron distinto y hacia dónde va.
Un ascensor roto y un hongo muy resistente
Hoare trabajaba entonces para Mozilla, la fundación que hace Firefox. Sabía que muchos de esos cuelgues vienen de errores en el manejo de la memoria, típicos de los programas escritos en C y C++, los lenguajes con los que se hace casi todo el software que tiene que ser rápido: sistemas operativos, navegadores, el firmware de un ascensor. Su idea era un lenguaje tan rápido como C y C++, pero en el que esos errores no se pudieran cometer, y sin la solución de Java o Python, un recolector de basura (garbage collector) que se encarga de la memoria a cambio de gastar recursos y de hacer pausas.
Le puso el nombre de un grupo de hongos, las royas, que según él están «sobrediseñados para sobrevivir»: tienen ciclos de vida de hasta cinco fases y varias formas de esporas, y atacan a plantas de todo el mundo.
Durante tres años fue un proyecto personal. En 2009, Mozilla decidió patrocinarlo, y durante una década llegó a tener a más de una docena de ingenieros dedicados a él, según los cálculos de Hoare. En 2013 Hoare dejó el proyecto en manos de otros, y ese mismo año Rust se quedó definitivamente sin recolector de basura. La primera versión estable, Rust 1.0, salió el 15 de mayo de 2015.
El primer gran examen llegó en 2017: Firefox empezó a usar un motor de CSS escrito en Rust, sacado de Servo, el navegador experimental de Mozilla. Lo llamaron Quantum CSS (antes, Stylo), y su gracia era repartir el trabajo entre todos los núcleos del procesador, algo que en C++ habría sido muy arriesgado. Cuando Mozilla recortó su plantilla en 2020, el lenguaje ya no dependía de ella: el 8 de febrero de 2021 nació la Rust Foundation, con AWS, Huawei, Google, Microsoft y Mozilla como miembros fundadores.
Las ideas que lo hicieron distinto
Rust no inventó casi ninguna de sus piezas: muchas venían de lenguajes académicos. Lo nuevo fue juntarlas en un lenguaje práctico, tan rápido como C, y hacer que el compilador las vigile todas. Estos son los conceptos clave, con programas que hemos compilado de verdad.
Cada dato tiene un solo dueño (ownership)
En Rust, cada valor pertenece a una variable, su dueña. Cuando la dueña desaparece, la memoria se libera sola, sin recolector de basura. Y si el valor pasa a otra variable, la anterior deja de poder usarlo. Así es imposible liberar la misma memoria dos veces o usarla después de liberarla, dos de los fallos de seguridad más comunes en C y C++:
fn main() {
let saludo = String::from("hola");
let otro = saludo; // la cadena pasa a tener un nuevo dueño: `otro`
println!("{otro}");
println!("{saludo}"); // error: `saludo` ya no es dueño de nada
}rustcerror[E0382]: borrow of moved value: `saludo`
--> propiedad.rs:5:16
|
2 | let saludo = String::from("hola");
| ------ move occurs because `saludo` has type `String`, which does not implement the `Copy` trait
3 | let otro = saludo; // la cadena pasa a tener un nuevo dueño: `otro`
| ------ value moved here
4 | println!("{otro}");
5 | println!("{saludo}"); // error: `saludo` ya no es dueño de nadaEl compilador no solo se niega: explica dónde se movió el valor y propone una solución (clonarlo, si de verdad hacen falta dos copias).
Prestar sin perder el control (borrowing)
Para usar un dato sin quedárselo, se presta con una referencia (&). La regla es sencilla: puede haber muchas referencias de solo lectura a la vez, o una sola que puede modificar el dato, pero nunca las dos cosas al mismo tiempo. La parte del compilador que lo comprueba se llama borrow checker, y es la fama, buena y mala, de Rust.
fn main() {
let mut lista = vec![1, 2, 3];
let primero = &lista[0]; // préstamo de solo lectura
lista.push(4); // error: no se puede modificar mientras alguien la está leyendo
println!("{primero}");
}rustcerror[E0502]: cannot borrow `lista` as mutable because it is also borrowed as immutable
--> prestamo.rs:4:5
|
3 | let primero = &lista[0]; // préstamo de solo lectura
| ----- immutable borrow occurs here
4 | lista.push(4); // error: no se puede modificar mientras alguien la está leyendo
| ^^^^^^^^^^^^^ mutable borrow occurs here
5 | println!("{primero}");
| ------- immutable borrow later used hereEste error parece exagerado, pero no lo es: al añadir un elemento, el vector puede necesitar más espacio y mudarse a otro sitio de la memoria, y primero apuntaría a donde ya no hay nada. En C++, ese mismo programa compila y falla, o no, según el día. Rust lo detecta antes de ejecutarlo. Las lifetimes (tiempos de vida) son la otra mitad de este sistema: el compilador comprueba que ninguna referencia dure más que el dato al que apunta.
Sin null y con los errores a la vista
Tony Hoare (que no es pariente de Graydon) llamó al valor nulo su «error de los mil millones de dólares». Rust no lo tiene: un valor que puede faltar es un Option, que vale Some(valor) o None, y el compilador obliga a tratar los dos casos. Con los errores pasa igual: en vez de excepciones, una operación que puede fallar devuelve un Result, que es Ok o Err:
fn dividir(a: i32, b: i32) -> Option<i32> {
if b == 0 { None } else { Some(a / b) }
}
fn main() {
for b in [2, 0] {
match dividir(10, b) {
Some(r) => println!("10 / {b} = {r}"),
None => println!("10 / {b}: no se puede dividir entre cero"),
}
}
let bien: Result<i32, _> = "42".parse();
let mal: Result<i32, _> = "cuarenta y dos".parse();
println!("{bien:?}");
println!("{mal:?}");
}salida10 / 2 = 5
10 / 0: no se puede dividir entre cero
Ok(42)
Err(ParseIntError { kind: InvalidDigit })El match obliga a cubrir todas las posibilidades: si falta el caso None, el programa no compila.
Concurrencia sin miedo
Los fallos más difíciles de encontrar son los que aparecen cuando varios hilos tocan los mismos datos a la vez: dependen del orden en que se ejecutan y a veces tardan meses en dar la cara. Rust marca cada tipo según si es seguro enviarlo a otro hilo (Send) o compartirlo entre hilos (Sync), y el compilador lo comprueba. Este programa intenta pasar a otro hilo un Rc, un contador de referencias que no está preparado para eso:
use std::rc::Rc;
use std::thread;
fn main() {
let datos = Rc::new(vec![1, 2, 3]); // Rc: contador de referencias sin protección entre hilos
let copia = Rc::clone(&datos);
let hilo = thread::spawn(move || println!("{copia:?}"));
hilo.join().unwrap();
}rustcerror[E0277]: `Rc<Vec<i32>>` cannot be sent between threads safely
--> hilos.rs:7:30
|
7 | let hilo = thread::spawn(move || println!("{copia:?}"));
| ------------- -------^^^^^^^^^^^^^^^^^^^^^^
| | |
| | `Rc<Vec<i32>>` cannot be sent between threads safely
| | within this `{closure@hilos.rs:7:30: 7:37}`
| required by a bound introduced by this callBasta con cambiar Rc por Arc, su versión con contador atómico, para que compile y funcione. La comunidad lo llama «concurrencia sin miedo» (fearless concurrency): no porque sea fácil, sino porque los errores salen al compilar y no en producción.
Y además
- Abstracciones de coste cero (zero-cost abstractions): los iteradores, los genéricos y los traits (las interfaces de Rust) se compilan a un código tan rápido como si se hubiera escrito a mano.
unsafecomo excepción visible: cuando hace falta saltarse las reglas, por ejemplo para hablar con el hardware, se marca el bloque conunsafe. El riesgo no desaparece, pero queda acotado a unas pocas líneas fáciles de revisar.- Cargo: el gestor de paquetes y de compilación viene incluido, con un repositorio común, crates.io. En C y C++ no hay nada equivalente que use todo el mundo.
- Mensajes de error que enseñan: como se ve arriba, el compilador explica el problema y casi siempre propone cómo arreglarlo.
El precio es una curva de aprendizaje empinada: al principio, el borrow checker rechaza programas que en otros lenguajes funcionarían, y hay que aprender a pensar como él. Y el compilador tampoco es infalible: hace poco se descubrió que tenía un agujero de casi 11 años que dejaba compilar código que leía memoria ya liberada.
Por qué tanta gente lo quiere
En la encuesta de Stack Overflow a desarrolladores, Rust ha sido el lenguaje más admirado (antes, «el más querido») año tras año desde 2016. En la de 2025, el 72 % de quienes lo usan quería seguir haciéndolo, por delante de Gleam (70 %), Elixir (66 %) y Zig (64 %).
Y los datos de seguridad le dan la razón. Microsoft calcula que el 70 % de las vulnerabilidades de su código vienen de errores de memoria. Google, que lleva años escribiendo en Rust las partes nuevas de Android, publicó en noviembre de 2025 que los fallos de memoria habían bajado por primera vez del 20 % de todas las vulnerabilidades de Android, cuando hace pocos años pasaban del 70 %. Según Google, el código en Rust tiene unas 1,000 veces menos vulnerabilidades de memoria por línea que el de C y C++. Además, sus cambios se revierten unas 4 veces menos y pasan un 25 % menos de tiempo en revisión.
Rust en Linux: de experimento a pieza fija
Linus Torvalds aceptó Rust en el kernel con Linux 6.1, publicado el 11 de diciembre de 2022, como un experimento: solo la infraestructura básica, para ver si funcionaba. No fue un camino tranquilo: hubo discusiones duras entre quienes mantienen el código en C y quienes empujaban Rust, y algún abandono sonado.
Tres años después, el experimento se dio por terminado. En la cumbre de mantenedores del kernel de diciembre de 2025, en Tokio, se acordó quitarle la etiqueta de experimental, y Miguel Ojeda, que dirige el proyecto Rust for Linux, lo dejó por escrito en el parche que cerraba la etapa: «Rust is here to stay» (Rust ha venido para quedarse). Según LWN, los móviles con Android 16 y el kernel 6.12 ya usan un módulo del kernel escrito en Rust (ashmem). Además, Linux 6.18 incorporó Binder, el sistema con el que se comunican las aplicaciones de Android, reescrito en Rust, y hay drivers gráficos en camino: Nova, para las tarjetas de NVIDIA, y Tyr, para las GPU Mali de Arm.
Fuera del kernel, el cambio es aún más visible. Ubuntu 26.10 usa ya por completo uutils, una reimplementación en Rust de las órdenes básicas como cp, mv o rm, que estaban escritas en C desde hace décadas. Y herramientas clásicas se reescriben en Rust por velocidad, como el enlazador mold 3.0.
La perspectiva es de crecimiento, pero lento y por capas. Rust sigue siendo una parte pequeña del kernel, y nadie plantea reescribir los más de 30 años de código en C que ya funcionan. Lo que sí está cambiando es dónde se escribe el código nuevo: drivers nuevos, sobre todo en gráficos, y piezas expuestas a datos de fuera, donde un fallo de memoria es más peligroso. El propio parche de Ojeda lo resume: hay Rust en producción, pero «queda muchísimo trabajo por hacer en todas las áreas».
Rust y la programación con IA
La llegada de los asistentes de IA ha dado a Rust un argumento inesperado. Un modelo de lenguaje escribe código que parece correcto y a veces no lo es, y en C o C++ un error de memoria puede pasar todas las pruebas y explotar meses después. En Rust, buena parte de esos errores se detecta al compilar, y el compilador explica qué falla. Para un agente de IA, que puede compilar, leer el error y corregir en bucle, eso es una ventaja enorme: el compilador hace de revisor estricto y gratuito. Hay investigación reciente que va más allá, como la «compilación generativa» de ETH Zúrich y Berkeley, que consulta al compilador mientras el modelo todavía está escribiendo, en vez de al final, y consigue que salgan menos programas que no compilan.
La IA también puede acelerar la migración desde C. La agencia de investigación militar de Estados Unidos, DARPA, tiene un programa llamado TRACTOR (Translating All C to Rust) para traducir C a Rust de forma automática, apoyado en modelos de lenguaje. En diciembre de 2025, un ingeniero distinguido de Microsoft, Galen Hunt, causó revuelo al publicar como objetivo de su equipo «un ingeniero, un mes, un millón de líneas de código» traducidas con IA. Después aclaró que es un proyecto de investigación y que Windows no se está reescribiendo en Rust.
Y el propio mundo de la IA ya se apoya en Rust. OpenAI reescribió en Rust su herramienta de programación en terminal, Codex CLI, en 2025, entre otras cosas para que se instale sin depender de Node.js. En decodigo hemos visto los dos lados: ArtCraft rehízo en Rust, con ayuda de Claude, trece aplicaciones de escritorio en dos semanas, y en nuestra comparación de Go y Rust en la época de la IA medimos lo que cuesta cada uno al compilar, al ejecutar y al mantener.
No es magia: un programa que compila en Rust puede seguir haciendo algo distinto de lo que se quería, y el código generado con IA abusa a veces de unsafe o de copias innecesarias. Pero cuando la IA escribe más código del que nadie puede revisar línea a línea, un lenguaje que descarta por sí solo una familia entera de fallos tiene mucho a su favor.
Veinte años después de aquel ascensor, Rust ha pasado de proyecto personal a lenguaje de los sistemas que no se pueden permitir fallar. No va a sustituir a C de la noche a la mañana, y su dificultad sigue espantando a mucha gente. Pero cada vez más código nuevo de Linux, de Android y de las propias herramientas de IA se escribe en él. Si quieres probarlo, tenemos un curso de Rust desde cero con ejemplos probados y un test de 24 preguntas para ver cuánto sabes.
Fuentes: Clive Thompson, «How Rust went from a side project to the world’s most-loved programming language», MIT Technology Review (14 de febrero de 2023): el ascensor, el nombre, el patrocinio de Mozilla y las cifras de Microsoft; Mozilla, Quantum CSS (Stylo); Rust Foundation; Linux 6.1 en kernelnewbies; LWN, «The state of the kernel Rust experiment» y la crónica de la cumbre de mantenedores; Google, «Rust in Android: move fast and fix things» (13 de noviembre de 2025); encuesta de Stack Overflow 2025; «Generative Compilation» (Mündler-Sasahara, Venev, Song, Vechev y He, 2026); DARPA TRACTOR; InfoWorld sobre Microsoft y Rust; InfoQ sobre Codex CLI. Los programas se compilaron con rustc 1.96.1 (edición 2024) y los errores y salidas son los reales. Esquemas: decodigo.com.