La historia del lenguaje Rust

Rust empezó como una afición en 2006: Graydon Hoare, ingeniero de Mozilla, irritado por el ascensor del edificio que se caía por un software en C. El nombre vino del hongo — “superingenierizado para sobrevivir”. Mozilla lo patrocinó en 2009. La 0.1 pública salió en 20 de enero de 2012. La 1.0, en 15 de mayo de 2015. En 3 de septiembre de 2026 la estable es la 1.98.1. Sin recolector de basura. Sin carreras de datos. El kernel Linux 6.1 (diciembre de 2022) aceptó el segundo idioma de la historia del proyecto: Rust, junto a C.

2006: el ascensor y el OCaml

Hoare tenía 29 años y trabajaba en Mozilla. El ascensor del apartamento se averiaba; lo achacó a bugs de memoria en el controlador. La tesis: se puede tener el rendimiento de C++ sin el comportamiento indefinido. Entre 2006 y 2009 el proyecto quedó en el tiempo libre. El primer compilador tenía unas 38 mil líneas de OCaml. Había cosas que después desaparecieron: OOP explícito con obj, análisis de typestate, un recolector de basura.

Las influencias, en sus palabras, eran “tecnología del pasado para salvar el futuro de sí mismo”: CLU, Erlang, Newsqueak, Limbo, Mesa, Sather, Alef. Manish Goregaoker lo resumió: investigación de décadas, no moda.

El nombre rust es el del óxido de los hongos, no el de la chapa. Superficie hostil, organismo terco.

La idea central: ownership y el borrow checker

Antes de seguir la cronología, vale la pena entender lo que Rust realmente inventó — porque no es sintaxis, es una regla de contabilidad que el compilador cobra.

En C asignas y liberas a mano, y te equivocas: usar después de liberar, liberar dos veces, desbordar el búfer. En Java o Go, un recolector de basura lo resuelve a cambio de pausas y memoria extra. Rust eligió la tercera puerta: ninguno de los dos. Cada valor tiene un único dueño; cuando el dueño sale del ámbito, la memoria se libera — en tiempo de compilación, sin runtime.

fn main() {
    let s1 = String::from("olá");
    let s2 = s1;              // a posse MOVE de s1 para s2
    println!("{s1}");          // erro de compilação: s1 não é mais dono
}

Para usar sin transferir la propiedad, presta — y aquí entra la regla que da nombre al borrow checker: o tienes varios préstamos de solo lectura, o uno único de escritura, nunca ambos a la vez.

let mut v = vec![1, 2, 3];
let primeiro = &v[0];      // empréstimo de leitura
v.push(4);                  // erro: precisaria de empréstimo de escrita
println!("{primeiro}");

Parece capricho — y es exactamente ese el paso en el que quien viene de C++ se rinde en la primera semana. Pero esa misma regla, aplicada entre hilos, es lo que elimina data race en tiempo de compilación. No es convención, no es buena práctica, no es revisión de código: el programa no compila. Por eso el kernel se interesó.

2009–2012: una cueva de nerd

En 2009 Mozilla lo oficializó. Brendan Eich (entonces CTO) y Research vieron un motor de navegador seguro. Entraron Patrick Walton, Niko Matsakis, Felix Klock, Goregaokar. La sala se convirtió en “nerd cave”, con un cartel en la puerta — apodo de Dave Herman. Ownership ya estaba en el diseño alrededor de 2010. El logo, en 2011, salió de una corona de bicicleta (chainring): la R dentro del engranaje.

El compilador pasó a autohospedarse, objetivo LLVM. En el 20 de enero de 2012 salió la 0.1 para Linux, Windows y macOS: la primera pública. El bootstrap en 2011 tardaba horas.

Hasta la 1.0: el GC desaparece, Graydon se va

De 2012 a 2015 el sistema de tipos se convirtió en el Rust actual. El GC, poco habitual en 2013, se eliminó. Desaparecieron el typestate, la pure, los punteros especiales y la sintaxis de canal. Quien venía de C++ aportó rendimiento; quien venía de scripting, Cargo; quien venía de ML, el tipo.

En 2013 Hoare dejó el día a día. La gobernanza se volvió federada: un core team de seis, luego nueve, RFCs a partir de marzo de 2014. Andrew Binstock en Dr. Dobb’s (ene/2014): lenguaje elegante, adopción lenta porque cambiaba con cada nightly.

En 15 de mayo de 2015 la 1.0. Compromiso de compatibilidad. Steve Klabnik escribió decenas de páginas de documentación en la recta final. Un año después: 1.400 contribuidores en el compilador, 5 mil crates. El cargo ya era el gestor oficial (2014).

Servo, Firefox, la prueba de fuego

Mozilla y Samsung financiaron el Servo (2012 en adelante): motor de navegador en Rust, laboratorio del lenguaje. Firefox 45 (2016) ya incluía código Rust. Componentes del Servo llegaron al 57 (septiembre de 2017), proyecto Quantum. Sin el navegador, la 1.0 habría sido otro lenguaje.

Fuera de Mozilla, pronto: Samsung, Facebook, Dropbox, Tilde (Ember). AWS en 2020. El argumento repetido: rendimiento, sin GC, sin data races, experiencia de compilador que empuja al código seguro.

Ediciones: 2018, 2021, 2024

Rust no rompe la versión antigua de la crate con el compilador nuevo. La crate declara la edition no Cargo.toml y convive con la toolchain actual.

• 2015 — a la 1.0.
• 2018 (1.31) — módulo, ? más ergonómico, non-lexical lifetimes.
• 2021 (1.56, out/2021) — disjoint capture en closures, resolución de prelude.
• 2024 — con la 1.85.0, en 20 de febrero de 2025.

async/await se estabilizó en la 1.39 (7 de noviembre de 2019). Sin esto, el Rust de servidor web no existiría como existe.

2020: Mozilla recorta, nace la Foundation

En agosto de 2020 Mozilla despidió a 250 personas — cerca de una cuarta parte de la plantilla. El equipo de Servo se disolvió. El core team anunció una fundación independiente para marcas y dominio. En 8 de febrero de 2021 nació la Rust Foundation: AWS, Google, Huawei, Microsoft, Mozilla. Meta y ARM entraron ese mismo año. Google, en abril de 2021, anunció Rust en el Android Open Source Project.

En junio de 2026 OpenAI entró en la Foundation. Marcas y política de trademark generaron peleas en 2023 (el borrador fue mal recibido). Gobernanza federada no es paz eterna — en noviembre de 2021 el equipo de moderación dimitió en protesta. El lenguaje sobrevivió a ambos.

El kernel: de la experiencia de 2022 al veredicto de 2025

Linus incluyó la infraestructura Rust en el merge de la 6.1 (Phoronix, 3 de octubre de 2022; estable en 11 de diciembre). Cerca de 12 mil líneas: build, crates mínimos, “hola mundo” de módulo. Segundo lenguaje del kernel después de C — pero entró declarado como experimento: si no funcionara, saldría.

En diciembre de 2025, en la Maintainers Summit, la sesión dirigida por Miguel Ojeda declaró el experimento un éxito, y Rust pasó a ser un lenguaje central del kernel junto a C y ensamblador. Los números que respaldaron la decisión:

• El driver Nova, para GPUs NVIDIA, con piezas ya en la línea principal; Tyr para Mali y el driver de Asahi para Apple Silicon en la misma línea.
• El binder de Android reescrito en Rust, integrado en la 6.18.
• El ashmem en Rust ejecutándose en Android 16 sobre el kernel 6.12 — millones de dispositivos reales con código Rust en el kernel.
• Debian habilitó Rust en las compilaciones del kernel, lo que aparece a partir de “forky”.
• La cantidad de código Rust en el kernel se quintuplicó en un año.

Dos frentes del compilador también avanzaron: el rustc_codegen_gcc, que injerta el generador de código de GCC en rustc, y el gccrs, el compilador de Rust del propio GCC — que ya consigue compilar el código Rust del kernel. Esto importa porque saca al kernel de la dependencia de un único compilador, vieja exigencia de la comunidad.

La política de versiones quedó pragmática: el kernel se compromete a compilar con la versión de Rust que esté en Debian estable, subiendo como mínimo de 6 a 12 meses después de cada release de Debian. Para este blog, el mensaje es el de siempre: el C del kernel dejó de ser dogma.

Dónde está Rust ya en tu distro

La parte que sorprende a quien no siguió de cerca: Rust dejó de ser “lenguaje de proyecto nuevo” y entró en el camino crítico del sistema que usas.

• Ubuntu 25.10 pasó a entregar el sudo por el sudo-rs, la reimplementación en Rust — con el sudo original aún disponible como alternativa en update-alternatives.
• Ubuntu 26.04 LTS es el primer LTS en traer las utilidades básicas del uutils/coreutils en Rust en lugar de los de GNU: ls, cp, mv y decenas de otros. La estrategia de Canonical fue la correcta — probar en las versiones intermedias antes de promover al LTS.
• En el kernel, los drivers en Rust citados arriba; en Android, el binder y el ashmem.

No hay consenso: parte de la comunidad cree que sustituir las coreutils de GNU por una reimplementación con licencia permisiva es una decisión política, no técnica. El argumento del otro lado es directo — ls e cp procesan entrada no confiable desde hace cincuenta años en C.

Instalando en Linux

La serie estable en 3 de septiembre de 2026 es la 1.98.1. El camino oficial es rustup, no el apt retrasado de la distro — Rust lanza cada seis semanas y el paquete de la distro se queda desactualizado rápido:

curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh
source "$HOME/.cargo/env"
rustc --version
cargo new ola && cd ola && cargo run

El rustup gestiona toolchains en paralelo: estable, beta y nightly, y es como cambias de canal sin romper nada:

rustup update
rustup toolchain install nightly
cargo +nightly build
rustup component add clippy rustfmt   # linter e formatador oficiais

El otro lado

Un post de historia que solo elogia no sirve para decidir nada. Lo que pesa en contra:

• Curva de aprendizaje real. El borrow checker no negocia. Las primeras semanas son de pelearse con el compilador, y la queja es legítima — solo pasa después de que el modelo mental de propiedad (ownership) entra.
• Tiempo de compilación. Un proyecto grande con muchas dependencias compila despacio, y la compilación limpia es sufrida. Mejoró mucho, aún molesta.
• El ecosistema asíncrono es complejo. async/await se estabilizó, pero el runtime no viene en la biblioteca estándar: eliges Tokio o async-std y vives con la consecuencia.
• “Reescribir en Rust” se convirtió en meme por algo. No todo software necesita esa garantía; gran parte de lo que se reescribe ni siquiera tenía un bug de memoria relevante para empezar.
• La gobernanza tiene fricción. En noviembre de 2021 el equipo de moderación dimitió en bloque; en 2023 el borrador de la política de marca fue rechazado por la comunidad. El lenguaje sobrevivió a ambos, pero no es el proyecto sereno que sugiere la propaganda.

Dicho esto: Dual MIT / Apache-2.0, sin un único dueño, con fundación. Ferris, el cangrejo, es la mascota de la comunidad — no es el logo. El logo es la corona de bicicleta.

Línea de tiempo

• 2006 — Graydon Hoare empieza el proyecto en su tiempo libre, en OCaml, después de un ascensor que se quedaba atascado por un bug de memoria.
• 2009 — Mozilla oficializa el patrocinio; nace la “nerd cave”.
• 2010 — el modelo de ownership ya está en el diseño.
• 2011 — el compilador pasa a autohospedarse, con objetivo LLVM; desaparece el logo de la corona de bicicleta.
• el 20 de enero de 2012 — 0.1, primera versión pública.
• 2012 — comienza el Servo, motor de navegador en Rust financiado por Mozilla y Samsung.
• 2013 — se elimina el recolector de basura; Hoare deja el día a día; la gobernanza se vuelve federada.
• Marzo de 2014 — comienza el proceso de RFCs.
• 15 de mayo de 2015 — la 1.0, con compromiso de compatibilidad.
• 2016 — Firefox 45 ya incluye código Rust.
• Septiembre de 2017 — Firefox 57 (proyecto Quantum) lleva componentes de Servo a producción.
• 2018 — edición 2018, en 1.31: módulos, ? ergonómico, non-lexical lifetimes.
• 7 de noviembre de 2019 — async/await se estabiliza en 1.39.
• Agosto de 2020 — Mozilla despide a 250 personas; el equipo de Servo se disuelve.
• 8 de febrero de 2021 — nace la Rust Foundation, con AWS, Google, Huawei, Microsoft y Mozilla.
• Abril de 2021 — Google anuncia Rust en el Android Open Source Project.
• Octubre de 2021 — edición 2021, en la 1.56.
• 11 de diciembre de 2022 — el kernel Linux 6.1 acepta la infraestructura Rust, como experimento.
• 20 de febrero de 2025 — edición 2024, en la 1.85.0.
• Mayo de 2025 — diez años de Rust estable.
• Octubre de 2025 — Ubuntu 25.10 entrega el sudo mediante sudo-rs.
• Diciembre de 2025 — el Maintainers Summit declara el experimento del kernel un éxito; Rust se convierte en lenguaje central junto a C.
• Junio de 2026 — OpenAI entra en la Rust Foundation.
• 2026 — Ubuntu 26.04 LTS trae coreutils en Rust; la estable es la 1.98.1.

Para seguir desde aquí

El mapa de idiomas de este blog: Las 7 principales lenguajes. El hermano de 2007 en Google, con filosofía opuesta: La historia del lenguaje Go. El kernel que abrió la puerta: Linux cumple 35 años e La historia de Linus Torvalds. Toolchain en Linux: Go e Swift.

Cierre

Un ascensor, un OCaml, una nerd cave, una 1.0 en 2015, un kernel en 2022, una 1.98.1 en 2026. Graydon describió el décimo aniversario (mayo de 2025) como infraestructura que apenas reconoce. El mensaje no ha cambiado: memoria segura sin GC, en el metal, en Linux.

Sitio: rust-lang.org · 1.0: 15 mayor 2015 · 1.98.1: blog.rust-lang.org/releases · Foundation: rustfoundation.org · diez años, en palabras de Hoare: 10 Years of Stable Rust.