En esta página

¿Qué es Rust? Instalación y primer programa

12 min lectura TextoCap. 1 — Fundamentos de Rust

¿Qué es Rust?

Rust es un lenguaje de programación de sistemas diseñado para ofrecer rendimiento comparable a C/C++ sin sacrificar la seguridad de memoria. Fue creado originalmente por Mozilla Research en 2010, y desde 2021 es administrado por la Rust Foundation, una organización sin fines de lucro con el respaldo de empresas como Microsoft, Google, Amazon, Meta y Huawei.

La propuesta de valor de Rust es única en el ecosistema de lenguajes de programación:

  • Seguridad de memoria sin recolector de basura (GC): Rust garantiza en tiempo de compilación que no habrá errores de segmentación, punteros colgantes, desbordamientos de búfer ni condiciones de carrera. Lo hace sin un GC que pueda pausar la ejecución.
  • Rendimiento de nivel sistema: El código Rust compila a binarios nativos altamente optimizados. No hay máquina virtual, no hay GC, no hay sobrecarga en tiempo de ejecución.
  • Concurrencia sin miedo: El sistema de tipos de Rust hace que los errores de concurrencia sean imposibles de compilar. Rust llama a esto "fearless concurrency".
  • Abstracciones de costo cero: Las abstracciones de alto nivel (iteradores, closures, traits genéricos) no tienen costo en tiempo de ejecución — se compilan al mismo código que escribirías a mano.

Por qué aprender Rust en 2026

Rust ha sido el lenguaje más amado en la encuesta anual de Stack Overflow durante más de nueve años consecutivos. Pero además del factor emocional, hay razones concretas:

  1. El kernel de Linux acepta código Rust desde la versión 6.1. Ya hay drivers escritos en Rust en el kernel oficial.
  2. Android usa Rust para componentes nuevos del sistema operativo, reduciendo vulnerabilidades de seguridad de memoria en un 70%.
  3. Windows incorpora componentes Rust en el kernel desde 2023.
  4. WebAssembly: Rust es el lenguaje principal para compilar a WASM de alto rendimiento.
  5. Salarios: Los desarrolladores Rust tienen salarios significativamente superiores al promedio según múltiples encuestas.

Instalación con rustup

rustup es el instalador oficial de Rust. Gestiona múltiples versiones del compilador y las herramientas asociadas.

En Linux y macOS:

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

En Windows: Descarga rustup-init.exe desde rustup.rs y ejecútalo.

Después de la instalación, reinicia tu terminal y verifica:

rustc --version   # rustc 1.94.0 (...)
cargo --version   # cargo 1.94.0 (...)
rustup --version  # rustup 1.27.x

Las herramientas del ecosistema

Al instalar Rust con rustup obtienes:

Herramienta Propósito
rustc El compilador de Rust
cargo El gestor de paquetes y herramienta de build
rustfmt Formateador de código oficial
clippy Linter con sugerencias avanzadas
rust-analyzer Language Server Protocol para IDEs

Cargo: el gestor de proyectos

Cargo es la herramienta central del ecosistema Rust. A diferencia de lenguajes donde el compilador y el gestor de paquetes son herramientas separadas, Cargo unifica todo:

# Crear un nuevo proyecto binario
cargo new mi-proyecto

# Crear una librería
cargo new mi-libreria --lib

# Compilar el proyecto
cargo build

# Compilar y ejecutar en modo desarrollo
cargo run

# Compilar en modo release (optimizado)
cargo build --release

# Ejecutar tests
cargo test

# Revisar el código sin compilar (más rápido)
cargo check

# Formatear código
cargo fmt

# Linting avanzado
cargo clippy

Estructura de un proyecto Cargo

mi-proyecto/
├── Cargo.toml      # Manifiesto del proyecto (dependencias, metadata)
├── Cargo.lock      # Versiones exactas de dependencias (para binarios)
└── src/
    └── main.rs     # Punto de entrada del programa

Para una librería, el archivo principal es src/lib.rs en lugar de src/main.rs.

Tu primer programa

Rust tiene una macro especial para imprimir: println!. La ! al final indica que es una macro, no una función. Las macros en Rust pueden aceptar un número variable de argumentos, lo cual es imposible con funciones regulares sin sobrecarga.

fn main() {
    println!("¡Hola, mundo!");
    
    // Formateo con llaves {}
    let x = 42;
    println!("El valor es: {}", x);
    
    // Desde Rust 1.58: captura de variables directa
    println!("El valor es: {x}");
    
    // Formateo de depuración con {:?}
    let tupla = (1, 2, 3);
    println!("{:?}", tupla);
    
    // Formateo pretty-print con {:#?}
    println!("{:#?}", tupla);
}

La filosofía de Rust: seguridad explícita

Una de las diferencias más importantes con otros lenguajes es que Rust hace explícitas las operaciones que pueden fallar. En lugar de excepciones que se propagan silenciosamente, Rust usa tipos como Result<T, E> y Option<T> para representar éxito/fallo y presencia/ausencia de valores.

Esta filosofía se resume en: si compila, probablemente funciona correctamente.

El compilador de Rust (rustc) tiene mensajes de error famosos por ser extremadamente claros y útiles. Cuando tu código no compila, el compilador no solo te dice qué está mal, sino que frecuentemente te sugiere cómo arreglarlo con mensajes del estilo: "help: considera agregar mut aquí".

Historia y evolución

  • 2006: Graydon Hoare inicia Rust como proyecto personal
  • 2010: Mozilla adopta el proyecto
  • 2015: Rust 1.0 — primera versión estable
  • 2021: Rust Foundation se constituye formalmente
  • 2022: Rust entra al kernel de Linux
  • 2024: Rust en el kernel de Windows
  • 2026: Rust 1.94 — el lenguaje sigue creciendo con estabilidad

Rust tiene un ciclo de lanzamientos de seis semanas: una nueva versión estable cada seis semanas, garantizando compatibilidad hacia atrás con código existente.

Configurar el editor

Para una experiencia de desarrollo óptima:

# Instalar rust-analyzer (Language Server)
rustup component add rust-analyzer

# Instalar el formateador
rustup component add rustfmt

# Instalar clippy
rustup component add clippy

En VS Code, instala la extensión "rust-analyzer" (ms-rust-lang.rust-analyzer). En IntelliJ/RustRover (JetBrains), la integración con Rust es de primera clase.

Compilar y ejecutar directamente

Aunque Cargo es la herramienta recomendada, también puedes compilar archivos individuales con rustc:

rustc main.rs
./main       # Linux/macOS
main.exe     # Windows

En proyectos reales siempre usarás Cargo, pero es útil conocer rustc para entender qué está pasando por debajo.

En la próxima lección exploraremos variables y mutabilidad — uno de los primeros conceptos donde Rust difiere radicalmente de otros lenguajes.

rustup administra tu toolchain
Usa rustup update para actualizar Rust a la última versión estable. Con rustup toolchain install nightly puedes instalar la versión nightly para experimentar con características en desarrollo.
Rust requiere un linker de C
En Windows instala Visual Studio Build Tools o usa el subsistema WSL2. En Linux instala gcc con tu gestor de paquetes. En macOS instala Xcode Command Line Tools con xcode-select --install. 
// src/main.rs — tu primer programa en Rust
fn main() {
    println!("¡Hola, mundo desde Rust 1.94!");

    // Rust infiere tipos automáticamente
    let nombre = "Rustáceo";
    let version: u32 = 94;

    println!("Hola, {}! Usamos Rust 1.{}", nombre, version);

    // Las variables son inmutables por defecto
    // nombre = "otro"; // Error: no se puede reasignar
}