Volver a los artículos

Aprender Rust en 2026: por qué, y para qué

Rust 13 min de lectura

Actualizado el 16 de noviembre de 2026. Varios de los proyectos que se citan están en desarrollo: su estado se indica en cada caso, con el enlace a la fuente.

Logotipo del lenguaje Rust Imagen: rust-lang.org.

Rust 1.100.0 salió el 12 de noviembre de 2026 (anuncio). Una semana antes, el director técnico de Discord anunció que todo el cliente se estaba reescribiendo en Rust. Entre una cosa y otra, puede que hayas instalado uv, ripgrep o Zed sin preguntarte en qué lenguaje estaban escritos.

Este artículo va dirigido a desarrolladores web que vienen de PHP o de JavaScript y se preguntan si Rust merece el tiempo que exige. Explica qué tiene de particular el lenguaje, qué se construye con él, quién lo usa de verdad, qué resulta difícil y por dónde empezar. Rust no es la respuesta adecuada para todos los proyectos, y la última parte indica en qué casos es más razonable elegir otra cosa.

Lo esencial en pocas líneas

  • Rust es un lenguaje compilado que comprueba en tiempo de compilación cómo usa la memoria tu código, sin recolector de basura.
  • Se usa sobre todo donde importan el rendimiento y el control de los recursos: herramientas de línea de comandos, servicios de red, componentes de sistema, aplicaciones de escritorio.
  • Para un desarrollador web, las puertas de entrada más naturales son una pequeña herramienta de línea de comandos y Tauri, que mantiene la interfaz en HTML, CSS y JavaScript.
  • Composer sigue escrito en PHP. Las herramientas en Rust que reproducen parte de su funcionamiento son proyectos independientes.
  • Aprenderlo exige esfuerzo, y las primeras semanas se van en buena parte en entender por qué el compilador rechaza un código que parecía correcto.

De dónde viene Rust

Rust empezó como un proyecto personal de Graydon Hoare, entonces empleado de Mozilla. El blog del proyecto sitúa su concepción en 2010, como proyecto de Mozilla Research, y añade que se puede retroceder hasta 2006 según cómo se cuente (Rust Blog). La pregunta de partida: cómo conseguir el rendimiento y el control de los lenguajes de sistemas eliminando toda una familia de errores de memoria y de concurrencia.

Fecha Acontecimiento
Hacia 2006 Primeros trabajos de Graydon Hoare.
2010 Rust pasa a ser un proyecto de Mozilla Research.
15 de mayo de 2015 Rust 1.0, con una promesa de estabilidad y compatibilidad.
Agosto de 2020 Mozilla despide a unas 250 personas, entre ellas miembros activos del proyecto. El equipo anuncia el plan de crear una fundación.
2021 Se crea la Rust Foundation.
Diciembre de 2025 Los mantenedores del kernel de Linux retiran la etiqueta «experimental» de Rust en el kernel (LWN).
12 de noviembre de 2026 Rust 1.100.0.

Qué lo distingue

Un compilador que comprueba quién es dueño de qué

La idea central de Rust se llama ownership (propiedad). Cada valor tiene un único propietario en cada momento. Cuando ese propietario sale del ámbito, la memoria se libera, sin recolector de basura y sin tener que escribir ningún free (The Rust Programming Language).

Este programa no compila:

fn main() {
    let nombres = vec![String::from("Ada"), String::from("Margaret")];
    let otro = nombres;           // el valor se mueve a `otro`
    println!("{:?}", nombres);    // rechazado: `nombres` ya no posee nada
}

El compilador responde esto:

error[E0382]: borrow of moved value: `nombres`
 --> move.rs:4:22
  |
2 |     let nombres = vec![String::from("Ada"), String::from("Margaret")];
  |         ------- move occurs because `nombres` has type `Vec<String>`, which does not implement the `Copy` trait
3 |     let otro = nombres;           // el valor se mueve a `otro`
  |                ------- value moved here
4 |     println!("{:?}", nombres);    // rechazado: `nombres` ya no posee nada
  |                      ^^^^^^^ value borrowed here after move
  |
help: consider cloning the value if the performance cost is acceptable

En PHP o en JavaScript este código funcionaría: las dos variables apuntarían al mismo array. Rust lo prohíbe porque tener dos propietarios para un mismo valor hace posibles las liberaciones dobles y los accesos a memoria ya liberada.

La solución habitual es el borrowing (préstamo): se presta el valor mediante una referencia y se conserva la propiedad.

fn mostrar(nombres: &Vec<String>) {
    println!("{:?}", nombres);
}

fn main() {
    let nombres = vec![String::from("Ada"), String::from("Margaret")];
    mostrar(&nombres);         // prestamos el valor, no lo entregamos
    println!("{} nombres", nombres.len());
}

La parte del compilador que aplica estas reglas se llama borrow checker (verificador de préstamos). Comprueba también que una referencia no viva más que el valor al que apunta, gracias a los lifetimes (tiempos de vida), y que un dato no se modifique en un sitio mientras se está leyendo en otro. Esta última regla es la que impide una parte de las condiciones de carrera entre hilos.

Sin null y sin excepciones

Rust no tiene valor nulo. Un valor que puede faltar es un Option, y una operación que puede fallar devuelve un Result. El compilador obliga a tratar los dos casos.

use std::fs;

fn leer_puerto(ruta: &str) -> Result<u16, String> {
    let contenido = fs::read_to_string(ruta)
        .map_err(|e| format!("no se puede leer el archivo: {e}"))?;

    contenido
        .trim()
        .parse::<u16>()
        .map_err(|e| format!("puerto no válido: {e}"))
}

fn main() {
    match leer_puerto("port.txt") {
        Ok(puerto) => println!("Puerto: {puerto}"),
        Err(mensaje) => eprintln!("Error: {mensaje}"),
    }
}

El ? devuelve el error a quien llama si la operación falla. La firma de la función dice que puede fallar, algo que una excepción de PHP no muestra.

Herramientas que vienen con el lenguaje

rustup instala y actualiza el compilador. cargo crea los proyectos, gestiona las dependencias, compila, ejecuta las pruebas y publica. rustfmt da formato al código y clippy señala las construcciones poco afortunadas. Quien está acostumbrado a Composer o a npm se orienta enseguida con Cargo.toml y cargo add.

Lo que Rust no garantiza

Rust tiene la palabra clave unsafe, que permite operaciones que el compilador no puede verificar (documentación). Un programa en Rust puede contener, además, errores de lógica, dependencias vulnerables o una mala configuración.

Google da un ejemplo concreto. En noviembre de 2025, su equipo de Android describió un desbordamiento de búfer encontrado en código unsafe de CrabbyAVIF, un componente escrito en Rust. El fallo, CVE-2025-48530, se corrigió antes de llegar a una versión pública (Google Security Blog). El mismo artículo indica que los fallos de seguridad de memoria bajaron del 20 % del total de vulnerabilidades de Android en 2025, y que la densidad de esos fallos es unas mil veces menor en el código Rust de Android que en su código C y C++.

Por qué se habla tanto de él

En la encuesta de Stack Overflow de 2025, Rust es el lenguaje más «admirado»: el 72,4 % de quienes lo han usado quieren seguir usándolo. En la misma encuesta, el 14,8 % de los encuestados dice utilizarlo (Stack Overflow Developer Survey 2025). Las dos cifras miden cosas distintas, y ambas proceden de un cuestionario que responden voluntarios.

La encuesta de la comunidad Rust publicada en marzo de 2026 reunió 7.156 respuestas, y sus autores advierten de que no se puede extrapolar demasiado a partir de esa muestra. Es útil por otro motivo: la lista de problemas que citan los propios usuarios empieza por la lentitud de la compilación, el espacio en disco que consume y una experiencia de depuración mejorable (State of Rust Survey 2025).

Qué se puede construir

Herramientas de línea de comandos

Es el terreno donde Rust es más visible en el día a día. ripgrep busca texto, fd busca archivos, bat los muestra con resaltado de sintaxis. En el mundo Python, uv gestiona proyectos y paquetes, y Ruff hace de linter y de formateador. Estas herramientas se distribuyen como un único ejecutable, sin runtime que instalar.

Para un desarrollador PHP, una primera herramienta puede ser muy modesta. Esta lista los paquetes de la sección require de un 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 ruta = env::args().nth(1).unwrap_or_else(|| "composer.json".to_string());

    let contenido = fs::read_to_string(&ruta).unwrap_or_else(|e| {
        eprintln!("No se puede leer {ruta}: {e}");
        process::exit(1);
    });

    let json: Value = serde_json::from_str(&contenido).unwrap_or_else(|e| {
        eprintln!("JSON no válido en {ruta}: {e}");
        process::exit(1);
    });

    match json["require"].as_object() {
        Some(paquetes) => {
            for (nombre, restriccion) in paquetes {
                println!("{nombre} {}", restriccion.as_str().unwrap_or("?"));
            }
        }
        None => println!("No hay sección \"require\" en {ruta}"),
    }
}
cargo run
# php >=8.3
# symfony/console ^7.2

Aplicaciones de escritorio

Hay dos enfoques. El primero conserva las tecnologías web. Tauri muestra una interfaz en HTML, CSS y JavaScript en la webview del sistema, y la lógica de la aplicación puede escribirse en Rust. Como no incluye un motor de navegador, su documentación dice que una aplicación mínima puede pesar menos de 600 KB. Sirve cualquier framework que genere HTML, CSS y JavaScript, y Tauri apunta también a Android e iOS. En móvil, la interfaz sigue siendo una página web dentro de una webview y no usa los componentes nativos del sistema.

npm create tauri-app@latest

Imagen de la documentacin de Tauri Imagen: Tauri.

El segundo enfoque dibuja la interfaz sin HTML. GPUI, el framework creado por el equipo del editor Zed, renderiza directamente con la GPU. Zed llegó a la versión 1.0 el 29 de abril de 2026 para macOS, Windows y Linux, y sus autores dicen que cientos de miles de desarrolladores lo usan cada día (Zed is 1.0). Iced y egui son otras dos bibliotecas de interfaz, con decisiones distintas sobre renderizado, accesibilidad y plataformas.

Imagen del anuncio de Zed 10 Imagen: Zed.

Servicios web y API

Axum y Actix Web son los dos frameworks que más se citan, y Tokio proporciona el runtime asíncrono sobre el que se apoya Axum. Un servicio mínimo con 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 { "Hola desde Axum" }));

    let listener = tokio::net::TcpListener::bind("127.0.0.1:3000")
        .await
        .unwrap();

    axum::serve(listener, app).await.unwrap();
}

Eso no quiere decir que haya que reescribir una API corriente. Para una aplicación de gestión con formularios, base de datos y panel de administración, Symfony, Laravel o Node.js permiten entregar antes con un equipo que ya los conoce. Rust empieza a interesar para un servicio concreto que maneja muchos datos o muchas conexiones, o cuya latencia tiene que mantenerse estable.

Componentes de sistema

Android usa Rust en su kernel, en firmware y en varios componentes de seguridad y de red, para el código nuevo y sin reescribir de forma sistemática lo que ya existe (Google, 2022).

Ubuntu ofrece un ejemplo con más matices. Desde la versión 25.10, sudo y las utilidades básicas las proporcionan reimplementaciones en Rust, sudo-rs y uutils coreutils. En su balance de abril de 2026, Canonical cuenta que dos auditorías de seguridad detectaron 113 problemas y dieron lugar a 45 CVE. En Ubuntu 26.04 LTS, cp, mv y rm siguen viniendo de GNU coreutils hasta que se resuelvan unos problemas de condición de carrera en el acceso a archivos (Ubuntu Discourse). Reescribir una herramienta en Rust elimina una clase de errores. Los errores de lógica siguen ahí, y la compatibilidad con el original hay que comprobarla caso por caso.

WebAssembly, móvil y juegos

Rust se compila a WebAssembly, lo que permite llevar al navegador un cálculo pesado y mantener JavaScript o TypeScript para la interfaz (The Rust and WebAssembly Book). Que compense depende del coste de pasar datos entre los dos lados. En móvil, Rust se usa sobre todo para compartir lógica entre Android e iOS. Para juegos, Bevy es un motor de código abierto escrito en Rust.

Discord: una reescritura anunciada que todavía no ha llegado

Discord usa Rust desde hace tiempo. En febrero de 2020, la empresa explicó por qué había reescrito en Rust su servicio «Read States», que guarda qué canales y qué mensajes ha leído cada usuario. La versión en Go sufría picos de latencia cada dos minutos, más o menos, cuando el recolector de basura recorría una caché grande en memoria. La versión en Rust ya no tenía esos picos y mejoraba la latencia, el uso de CPU y el de memoria (Discord). La empresa ha descrito también servicios en Rust en su almacenamiento de mensajes.

El 5 de noviembre de 2026, Stanislav Vishnevskiy, cofundador y director técnico, anunció en X que todo el cliente pasaba a Rust: «Electron desaparece, y React Native también; el móvil mantiene una interfaz nativa, pero comparte el código de la aplicación con el escritorio a través de Rust» (The Verge). Según IT-Connect, la interfaz de escritorio se apoya en GPUI, la webview del sistema se seguiría usando para algunas integraciones, y una primera versión para Windows mostraba 290 MB de memoria RAM con dos cuentas conectadas.

Captura del futuro cliente de Discord publicada por ITConnect Imagen: IT-Connect.

Ese cliente no está disponible. Discord dice que espera ponerlo pronto a prueba con usuarios y no ha dado ninguna fecha. Las cifras de memoria vienen de una demostración de la propia empresa, con una versión sin terminar.

PHP: alternativas a Composer escritas en Rust

Composer, el gestor de dependencias del ecosistema PHP, está escrito en PHP y así sigue. No se ha portado a Rust. Lo que sí existe son proyectos independientes que reproducen o aceleran una parte de su trabajo.

  • Vivacity reimplementa cinco comandos: install, update, require, remove y dump-autoload. La herramienta ePHPm lo integra, y su documentación lo dice de forma explícita: «ephpm composer no es Composer». Fuera de esos cinco comandos, le pasa el trabajo a un Composer de verdad o se detiene con un error (ePHPm).
  • Composr se centra en la instalación en frío de proyectos Laravel. Funciona en modo híbrido: cuando un script llama a un método de una clase PHP, delega ese evento en el Composer real. Sus autores miden, en una aplicación de 292 paquetes y sin ninguna caché, unos 33 segundos frente a 72 con Composer. Es su medición, en su proyecto.
  • Libretto lee composer.json y composer.lock. Sus autores lo presentan como software alfa, experimental, que no sustituye a Composer tal cual, porque los plugins de Composer son código PHP que un programa en Rust no puede ejecutar sin un intérprete.

Antes de usar alguno en un proyecto real, comprueba la compatibilidad con tus plugins y tus scripts, y mantén Composer como referencia en producción.

Lo que cuesta

Para quien viene de PHP o de JavaScript, hay varios conceptos nuevos a la vez: la propiedad y el préstamo, los tiempos de vida, la gestión de errores con Result, las restricciones para compartir datos entre hilos y las diferencias entre código síncrono y asíncrono. El compilador rechaza código que parece correcto, y hace falta tiempo para que sus rechazos se vuelvan previsibles. Sus mensajes ayudan, como el que aparece más arriba, que señala la línea problemática y propone una corrección.

Los tiempos de compilación son la primera queja de los usuarios en la encuesta de 2026. La madurez de las bibliotecas varía mucho de un ámbito a otro. En un equipo, el tiempo de formación y la dificultad para contratar pesan tanto como las cualidades del lenguaje.

Rust probablemente no sea la primera opción para un sitio web o una aplicación de gestión corrientes, para un prototipo que hay que entregar deprisa o para un proyecto en cuyo equipo nadie lo conoce. Complementa a PHP, JavaScript o Python en necesidades concretas y no obliga a reescribir nada.

Por dónde empezar

La instalación se hace con rustup (página oficial):

curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh

cargo new hola
cd hola
cargo run

Recursos gratuitos:

  • Comprehensive Rust, el curso del equipo de Android de Google. Va de la sintaxis básica a los genéricos y la gestión de errores, con cuatro días para los fundamentos, y da por hecho que ya sabes programar. Está en español, francés e inglés, entre otros idiomas. La traducción al español deja algunos títulos en inglés: la página sobre la propiedad, por ejemplo, se titula «Ownership».
  • The Rust Programming Language, el libro oficial, en inglés.
  • Rust by Example para aprender con ejemplos cortos, y Rustlings para ejercicios que se corrigen en el terminal.
  • La documentación de Cargo.

Algunos primeros proyectos al alcance de un desarrollador web:

  1. una herramienta de línea de comandos que busque texto en un proyecto;
  2. un programa que lea un archivo JSON o CSV y genere un informe;
  3. una utilidad que revise archivos composer.json o package.json, como el ejemplo de más arriba;
  4. una pequeña API con Axum;
  5. una aplicación de escritorio con Tauri, manteniendo una interfaz web.

Fuentes

El lenguaje y su historia:

Encuestas:

Proyectos y empresas:

PHP y Composer:


Artículo escrito por Jatniel, desarrollador full stack PHP sénior.

Puedes encontrarme en LinkedIn, GitHub y X.

Compartir este artículo

Me gustaría usar Google Analytics para saber qué páginas te resultan útiles. No se guarda nada sin tu consentimiento. Más información