Hola Mundo en Rust: instalar y ejecutar en Ubuntu

Todo el mundo empieza por uno Hello, world!. Este post usa ese programa de tres líneas como excusa para instalar el Rust en Ubuntu como es debido, entender lo que hace el cargo y salir de aquí con un proyecto que compila, en unos diez minutos.

Por qué Rust, en dos frases

Rust ofrece el rendimiento de C sin recolector de basura y, al mismo tiempo, elimina en tiempo de compilación la clase de fallos que más CVE genera en el software de sistemas: uso de memoria después de liberarla, desbordamiento de búfer, condiciones de carrera entre hilos. El precio es un compilador que discute contigo la primera semana.

No es un lenguaje de nicho: el kernel de Linux quitó la etiqueta de experimental a Rust en la versión 7.0, en abril de 2026, y Ubuntu 26.04 LTS ya incluye el sudo y las utilidades básicas reescritas en él. La historia completa está en La historia del lenguaje Rust.

Instalando con rustup

No uses el apt install rustc. Rust lanza cada seis semanas y el paquete de la distro se queda obsoleto rápido — además de no proporcionar el rustup, que es quien gestiona las versiones. El camino oficial:

sudo apt update
sudo apt install -y build-essential curl    # o Rust usa o linker do GCC

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

Acepta la instalación por defecto (opción 1). Al terminar, carga el entorno en la sesión actual — en las siguientes ya se cargará solo por ~/.bashrc:

source "$HOME/.cargo/env"

rustc --version
cargo --version

Debería ver algo como rustc 1.98.1. Si el comando no se encuentra, es porque el ~/.cargo/bin no entró en el PATH — el source anterior lo soluciona.

El primer programa, a mano

Antes del cargo, vale la pena ver el compilador nu. Cree ola.rs:

fn main() {
    println!("Olá, mundo!");
}

rustc ola.rs
./ola

Dos cosas para reparar. El rustc generó un binario nativo — sin VM, sin intérprete, sin runtime para instalar en la máquina de destino. Y el println! tiene una exclamación: en Rust, eso significa que es un macro, no una función común. Verás este signo de exclamación con frecuencia.

Ahora con el método correcto: cargo

En la práctica nadie llama al rustc a mano. El cargo es el gestor de proyecto, de dependencias y de build — el equivalente a lo que npm, pip e make hacen juntos en otros lenguajes.

cargo new ola
cd ola
cargo run

Crea la estructura, compila y ejecuta. Lo que ha aparecido:

ola/
├── Cargo.toml      # nome, versão, dependências
├── .gitignore      # já vem pronto
└── src/
    └── main.rs     # o seu código

Los comandos que usarás cada día:

cargo run                 # compila e executa
cargo build               # só compila (binário em target/debug/)
cargo build --release     # compila otimizado — bem mais lento, bem mais rápido
cargo check               # verifica se compila, SEM gerar binário (o mais rápido)
cargo test                # roda os testes
cargo fmt                 # formata o código no padrão da comunidade
cargo clippy              # o linter: pega o que compila mas é má ideia

cargo check es el secreto de productividad en Rust: mientras escribes, responde en una fracción del tiempo de build, porque no genera código máquina.

Si clippy y fmt no están instalados:

rustup component add clippy rustfmt

Un paso más allá del “hola”: leyendo la entrada

Un Hello, world! no muestra nada de lo que hace al lenguaje diferente. Este sí lo muestra — cambia el contenido de src/main.rs:

use std::io::{self, Write};

fn main() {
    print!("Qual o seu nome? ");
    io::stdout().flush().unwrap();

    let mut nome = String::new();
    io::stdin()
        .read_line(&mut nome)
        .expect("falha ao ler a entrada");

    let nome = nome.trim();

    if nome.is_empty() {
        println!("Você não digitou nada.");
    } else {
        println!("Olá, {nome}! Bem-vindo ao Rust.");
    }
}

cargo run

Tres detalles que valen más que el programa:

• let mut — en Rust todo es inmutable por defecto. Si quieres poder modificarlo, tienes que indicarlo. Es el inverso de la mayoría de lenguajes, y es a propósito.
• &mut nome — estás prestando la variable a la función para que pueda escribir en ella, sin transferir la propiedad. Este concepto es el corazón de Rust; el compilador garantiza que solo exista un préstamo de escritura a la vez.
• .expect(...) — leer de la entrada puede fallar, y Rust te obliga a gestionarlo. No existe ninguna excepción oculta: o gestionas el error, o el programa no compila.

Usando una dependencia

crates.io es el repositorio de paquetes del lenguaje. Añadir uno es un comando:

cargo add rand

Esto escribe la dependencia en Cargo.toml solo. Ahora un sorteo:

use rand::Rng;

fn main() {
    let sorteado = rand::rng().random_range(1..=100);
    println!("Número sorteado: {sorteado}");
}

cargo run

En la primera ejecución descarga y compila la dependencia y todas sus dependencias; en las siguientes utiliza la caché. El archivo Cargo.lock, creado automáticamente, fija las versiones exactas — inclúyelo en el control de versiones junto con el proyecto si es un binario.

Generando el binario de producción

cargo build --release
ls -lh target/release/ola
./target/release/ola

El binario en release está optimizado y no depende de que Rust esté instalado en la máquina de destino — solo de las bibliotecas del sistema. Por eso tantas herramientas de línea de comandos modernas se distribuyen como un único archivo.

Gestionando versiones de Rust

rustup update                    # atualiza a toolchain
rustup toolchain install nightly # instala o canal de desenvolvimento
cargo +nightly build             # compila com ele, sem trocar o padrão
rustup default stable            # volta ao estável
rustup show                      # o que está instalado e ativo

Para fijar la versión de un proyecto específico, crea un rust-toolchain.toml en la raíz — lo rustup pasa a respetarlo automáticamente allí dentro.

Cuando se atasque

Se va a bloquear, y no pasa nada. El compilador de Rust es el más didáctico que existe: suele decir no solo qué está mal, sino qué escribir en su lugar. Lee el mensaje entero antes de buscar en Google — la respuesta casi siempre está en él.

rustc --explain E0502     # explicação longa de qualquer código de erro

Y, si aun así no se soluciona, pegar el mensaje en un asistente de IA en la terminal resuelve la mayor parte de los atascos de un principiante sin sacarte del teclado.

Por dónde seguir

• El libro oficial, gratuito y en español: El Libro de Rust. Es la mejor puerta de entrada que existe.
• Rust by Example — si aprendes mejor leyendo código que texto.
• Rustlings — ejercicios pequeños que compilan mal a propósito, para que los arregles.
• Aquí en el blog: La historia del lenguaje Rust, con el borrow checker explicado, y las principales lenguajes de programación, para situar a Rust en el mapa.

Diez minutos, un binario nativo y un cangrejo. Es un buen comienzo.

Engranaje basado en el logo oficial de Rust (CC BY 4.0). Ferris, mascota extraoficial, por Karen Rustad Tölva.