Dónde brilla Rust en 2026

En 2026 Rust ya no es una promesa: es infraestructura en producción en las mayores empresas de tecnología del mundo, y el segundo lenguaje admitido oficialmente en el kernel de Linux tras C. Esta lección recorre los dominios donde Rust brilla y, más importante, muestra por qué en cada uno es la misma propiedad (seguro, sin GC, coste cero) la que lo hace ganar. No brilla por moda: brilla porque encaja.

Un mismo motor, muchos vehículos

La razón de que Rust aparezca en dominios tan dispares es que todos comparten una necesidad: rendimiento predecible sin sacrificar la seguridad. Donde eso importa, Rust encaja como un guante.

Backend web: un servicio con axum

El ecosistema web de Rust está maduro. axum (sobre el runtime Tokio) y actix-web son los frameworks dominantes en 2026: componibles, tipados y con un rendimiento que compite con lo más rápido que existe. Un servicio de salud completo cabe en pocas líneas:

use axum::{routing::get, Json, Router};
use serde::Serialize;

#[derive(Serialize)]
struct Estado {
    ok: bool,
    version: &'static str,
}

async fn salud() -> Json<Estado> {
    Json(Estado { ok: true, version: "1.0.0" })
}

#[tokio::main]
async fn main() {
    let app = Router::new().route("/salud", get(salud));
    let listener = tokio::net::TcpListener::bind("0.0.0.0:3000").await.unwrap();
    println!("escuchando en el puerto 3000");
    axum::serve(listener, app).await.unwrap();
}

Fíjate en lo que no hay: ni recolector que meta pausas bajo carga, ni null que provoque el clásico “error de las mil millones de dólares” (el tipo Json<Estado> garantiza que la respuesta existe y tiene la forma correcta). El compilador verifica el contrato de la API antes de que despliegues nada.

CLI, WASM y embebido

Línea de comandos. Aquí Rust arrasó primero. Con clap defines una interfaz mediante tipos y obtienes parseo, validación y ayuda gratis:

use clap::Parser;
use std::path::PathBuf;

#[derive(Parser)]
#[command(version, about = "cuenta las lineas de un archivo")]
struct Args {
    /// ruta del archivo a leer
    ruta: PathBuf,
}

fn main() -> std::io::Result<()> {
    let args = Args::parse();
    let texto = std::fs::read_to_string(&args.ruta)?;
    println!("{} lineas", texto.lines().count());
    Ok(())
}

El binario resultante es un único ejecutable estático, sin runtime que instalar: por eso ripgrep o uv se distribuyen tan fácil y arrancan al instante.

Embebido. En un microcontrolador no hay sistema operativo ni heap por defecto. Rust corre ahí en modo no_std, freestanding, conservando el borrow checker y sin coste de runtime:

#![no_std]
#![no_main]

use panic_halt as _;

// Sin SO, sin asignador global, sin GC: solo tu codigo y el hardware,
// pero con las mismas garantias de memoria que en un servidor.

WebAssembly. Compilando al objetivo wasm32, ese mismo control y esa ausencia de un runtime pesado convierten a Rust en el lenguaje ideal para llevar cómputo intensivo al navegador sin la sobrecarga de arrastrar un recolector de basura.

Sistemas y el kernel de Linux

El hito más simbólico llegó en 2022: Rust for Linux integró Rust como segundo lenguaje del kernel, junto a C, tras cinco décadas de monopolio. En 2026 ya hay drivers reales escritos en Rust en el árbol oficial (controladores gráficos, de red, sistemas de archivos). La motivación es exactamente la de este track: la inmensa mayoría de las vulnerabilidades del kernel son bugs de memoria, y Rust los convierte en errores de compilación sin renunciar al control absoluto que un kernel exige.