Herramientas de Rust: todo lo que necesitas para empezar

Cuando empiezas con Rust, escuchas muchos nombres nuevos de golpe: rustup, rustc, cargo, clippy, rustfmt, rust-analyzer. Puede parecer que necesitas diez herramientas antes de escribir una sola línea. La buena noticia: un solo instalador te da casi todas, y cada herramienta tiene una tarea clara.

Piénsalo como una cocina. rustup es la tienda que te trae el equipo y lo cambia cuando hace falta. cargo es el chef que lo dirige todo. clippy es el profesor amable que mira por encima de tu hombro, y rustfmt mantiene la encimera ordenada. Esta página explica cada herramienta, lo que necesitas en tu sistema operativo y cómo las usa a diario alguien que programa en Rust.

Si todavía no has instalado Rust, la instalación paso a paso y tu primer proyecto están en Empezar con Rust. Lo básico de cargo (cargo new, cargo add, Cargo.toml) está en Cargo y crates. Esta página parte de las dos.

La visión general

Aquí tienes toda la caja de herramientas en una tabla:

Herramienta	Qué hace	¿Viene con rustup?
`rustup`	Instala Rust, lo actualiza y cambia entre versiones	Es el instalador
`rustc`	El compilador: convierte tus archivos `.rs` en un programa	Sí
`cargo`	Compila, ejecuta, prueba y añade crates. Lo usas para casi todo	Sí
`rustup doc`	Abre en tu navegador la documentación de la biblioteca estándar y el Rust Book sin conexión	Sí (perfil `default`)
`clippy`	Un linter: señala errores y formas más sencillas de escribir tu código	Sí (perfil `default`)
`rustfmt`	Un formateador: reescribe tu código con el estilo estándar	Sí (perfil `default`)
`rust-analyzer`	El “cerebro del editor”: autocompletado, errores en línea, pistas de tipos, ir a la definición	No por defecto. La extensión de VS Code trae su propia copia
Un depurador	Detiene tu programa en una línea para que mires sus variables	No. Instalas LLDB o GDB (o una extensión del editor que incluya uno)

Un perfil (profile) es un grupo de componentes que instala rustup. La instalación normal usa el perfil default, que añade la documentación, clippy y rustfmt al compilador y a cargo. Si alguien configuró tu máquina con el perfil minimal, cargo clippy te dirá que no está instalado. Un comando lo arregla: rustup component add clippy rustfmt.

Prueba rustup doc --std alguna vez. Abre la documentación completa de la biblioteca estándar desde tu propio disco, así que funciona en un avión o con una conexión lenta. Para la documentación de tu propio proyecto y de cada crate que usa, ejecuta cargo doc --open (más sobre esto en Documentación).

Antes de instalar: lo que necesita cada sistema operativo

Rust compila tu código, pero al final necesita un linker (enlazador): un programa que une las piezas compiladas en un solo archivo que puedes ejecutar. Rust usa el linker que traen las herramientas de C de tu sistema. Por eso cada sistema operativo necesita un pequeño paso extra.

Sistema operativo	Qué instalar	Cómo
Windows (recomendado)	Las herramientas de C++ de Visual Studio: el linker de MSVC y el SDK de Windows	Elige la carga de trabajo Desarrollo para el escritorio con C++ (Desktop development with C++) en el instalador de Visual Studio
Windows (alternativa)	La toolchain de GNU (MinGW)	`rustup toolchain install stable-gnu`
Windows (otra opción)	WSL, un Linux de verdad dentro de Windows	`wsl --install`, y luego sigue los pasos de Linux
macOS	Las herramientas de línea de comandos de Apple (incluyen un compilador de C y un linker)	`xcode-select --install`
Debian / Ubuntu	Un compilador de C y un linker	`sudo apt install build-essential`
Fedora	Un compilador de C y un linker	`sudo dnf install gcc`

Algunas notas sinceras:

Windows y Visual Studio. No tienes que buscarlo tú: si falta Visual Studio, rustup-init.exe te ofrece instalarlo. Instala Visual Studio Community, que es gratis para particulares, estudiantes y proyectos de código abierto, pero no para todas las empresas. Si lo instalas en el trabajo, pregunta qué edición usa tu empresa. Al seleccionar la carga de trabajo “Desarrollo para el escritorio con C++” obtienes todo lo que necesita Rust.
Windows y GNU. La toolchain de MSVC es la predeterminada y es la que mejor funciona con el resto del software de Windows. La toolchain de GNU no necesita Visual Studio para programas sencillos, pero muchos crates que incluyen código en C no compilarán hasta que instales también MSYS2 con MinGW. Lo mejor para la mayoría es quedarse con MSVC.
WSL es una gran opción si quieres un entorno Linux en Windows (por ejemplo, porque tu servidor usa Linux). Dentro de WSL, instalas Rust con el comando normal de Linux, aparte de cualquier instalación en Windows.
Extras en Linux. Algunos crates populares hablan con bibliotecas del sistema. Si una compilación falla con un mensaje sobre pkg-config u OpenSSL, en Ubuntu instala también pkg-config y libssl-dev.

Después de esto, sigue los pasos de instalación de Empezar con Rust.

rustup en la práctica

Una vez instalado Rust, rustup es la herramienta con la que lo mantienes. Sale una nueva versión estable de Rust cada seis semanas, así que actualizar es una costumbre normal:

rustup update     # actualiza todas las toolchains instaladas (y el propio rustup)
rustup show       # qué está instalado y qué toolchain está activa aquí

rustup show imprime algo parecido a esto (recortado):

Default host: x86_64-unknown-linux-gnu

installed toolchains
--------------------
stable-x86_64-unknown-linux-gnu (active, default)

active toolchain
----------------
name: stable-x86_64-unknown-linux-gnu
active because: it's the default toolchain

Stable, beta y nightly

Una toolchain (cadena de herramientas) es un conjunto completo de rustc, cargo y compañía. Rust tiene tres canales de publicación:

Canal	Qué es	Úsalo cuando
stable	La versión oficial, cada seis semanas	Casi siempre. Esta es la que quieres
beta	La próxima versión estable, en pruebas	Quieres comprobar tu proyecto antes de la próxima versión
nightly	Se compila cada noche, con funciones experimentales	Una herramienta o un crate la pide, o quieres probar una función nueva

Puedes tener varias toolchains instaladas a la vez:

rustup toolchain install nightly   # instala nightly junto a stable
cargo +nightly build               # usa nightly solo para este comando
rustup default stable              # elige la toolchain que se usa en todas partes

Fijar una toolchain para un proyecto

A veces un proyecto necesita una versión concreta de Rust. Pon un archivo llamado rust-toolchain.toml en la carpeta del proyecto y rustup cambiará de versión automáticamente cada vez que trabajes en esa carpeta:

[toolchain]
channel = "1.97.0"
components = ["clippy", "rustfmt"]
targets = ["wasm32-unknown-unknown"]

Sube este archivo a git. Así todo tu equipo (y tu CI) usa exactamente el mismo compilador, y rustup lo instala si les falta. La mayoría de los proyectos pequeños no necesitan este archivo; simplemente usan la última versión estable.

Componentes y targets

Los componentes (components) son piezas extra de una toolchain. Los targets (plataformas de destino) te permiten compilar para otro tipo de máquina:

rustup component add clippy rustfmt rust-src   # rust-src: código fuente de std, lo usa rust-analyzer
rustup component list --installed              # mira lo que tienes
rustup target add wasm32-unknown-unknown       # compila Rust para el navegador

El target wasm32-unknown-unknown es el que necesitas para WebAssembly.

Editores e IDE

Puedes escribir Rust en cualquier editor de texto, pero un editor con rust-analyzer (o un motor parecido) marca una diferencia enorme. Ves los errores mientras escribes, los tipos de tus variables aparecen junto a ellas y puedes saltar a la definición de cualquier función. Para quien empieza, esa ayuda es como tener un tutor paciente.

Editor	Precio	Soporte para Rust	Ideal para
VS Code + rust-analyzer	Gratis	Extensión oficial rust-analyzer	La mayoría de la gente. Es la opción más popular, y casi todas las guías dan por hecho que lo usas
RustRover (JetBrains)	Gratis para uso no comercial (aprender, proyectos personales, código abierto sin pago). El trabajo comercial necesita una suscripción de pago	Integrado, con el motor de Rust propio de JetBrains y un depurador incluido	Quien prefiere un IDE completo con todo incluido
Zed	Gratis, código abierto	Integrado (usa rust-analyzer, y CodeLLDB para depurar)	Un editor moderno y muy rápido
Neovim / Helix	Gratis, código abierto	A través de rust-analyzer. Helix funciona casi sin configurar; Neovim necesita un poco de configuración	Quien disfruta trabajando en la terminal
Visual Studio	Ediciones de pago, más la Community gratuita	Sin soporte oficial para Rust	No encaja bien con Rust. Solo necesitas sus C++ Build Tools para el linker

Las condiciones de la licencia de RustRover pueden cambiar, así que revisa la página de RustRover (en inglés) para conocer las reglas actuales antes de usarlo en el trabajo.

Para Neovim, Helix y otros editores, instala el programa rust-analyzer con rustup component add rust-analyzer.

Extensiones recomendadas para VS Code

Si usas VS Code, estas cuatro cubren casi todo:

rust-analyzer: la imprescindible. Autocompletado, errores, pistas y refactorización.
CodeLLDB: un depurador para poner puntos de interrupción y avanzar por el código paso a paso. Incluye su propia copia de LLDB.
Even Better TOML: colorea y revisa tu Cargo.toml.
Error Lens (opcional): muestra los mensajes de error directamente en la línea, no solo al pasar el ratón. A algunas personas les encanta; a otras les parece demasiado ruido.

Depuración

Puntos de interrupción con CodeLLDB

Con rust-analyzer y CodeLLDB instalados en VS Code, verás unos pequeños enlaces Run | Debug encima de fn main y encima de cada test. Haz clic en el borde izquierdo de un número de línea para poner un punto rojo de interrupción (breakpoint) y luego haz clic en Debug. El programa se detiene en tu punto de interrupción, y puedes mirar cada variable y avanzar por el código línea a línea.

Si quieres una configuración reutilizable (por ejemplo, para pasar argumentos de línea de comandos), crea .vscode/launch.json:

{
  "version": "0.2.0",
  "configurations": [
    {
      "type": "lldb",
      "request": "launch",
      "name": "Debug task_queue",
      "cargo": {
        "args": ["build", "--bin=task_queue"]
      },
      "args": [],
      "cwd": "${workspaceFolder}"
    }
  ]
}

La parte cargo le dice a CodeLLDB que primero compile tu programa con cargo y después lo arranque en el depurador. Cambia task_queue por el nombre de tu paquete y pon los argumentos del programa en "args". Pulsa F5 para empezar.

Comprobaciones rápidas con `dbg!`

No siempre necesitas un depurador completo. La macro dbg! imprime una expresión, su valor y el archivo y la línea donde la escribiste. Además devuelve el valor, así que puedes envolver casi cualquier cosa con ella sin cambiar lo que hace tu código:

fn apply_discount(price: u32, percent: u32) -> u32 {
    price - price * percent / 100
}

fn main() {
    let prices = [120, 45, 80];

    let total: u32 = dbg!(prices.iter().sum());
    let final_price = dbg!(apply_discount(total, 10));

    println!("Total con un 10% de descuento: {final_price}");
}

Salida:

Total con un 10% de descuento: 221

▶ Pruébalo tú mismo

¿Dónde están las líneas de dbg!? dbg! imprime en stderr (la salida de errores), no en stdout como println!. Así tus notas de depuración quedan separadas de tu salida real. En tu terminal, o en la sección “Standard Error” del Playground, también verás:

[src/main.rs:8:22] prices.iter().sum() = 245
[src/main.rs:9:23] apply_discount(total, 10) = 221

Quita tus llamadas a dbg! cuando termines. Son para ti, no para tus usuarios.

Calidad del código en el día a día

Tres comandos mantienen tu código sano. Son rápidos, así que ejecútalos a menudo.

`cargo check`: respuesta rápida

cargo check encuentra errores de compilación sin generar un programa ejecutable, así que es mucho más rápido que cargo build. Mucha gente lo ejecuta cada pocos minutos. (El rust-analyzer de tu editor hace una comprobación como esta cada vez que guardas).

`cargo fmt`: nunca más discusiones de estilo

cargo fmt reescribe todos los archivos de tu proyecto con el estilo estándar de Rust. Nadie en tu equipo tiene que volver a pensar en espacios o saltos de línea. Convierte esto:

struct Player{name:String,score:u32}
fn top(players:&[Player])->Option<&Player>{players.iter().max_by_key(|p|p.score)}

en esto:

struct Player {
    name: String,
    score: u32,
}
fn top(players: &[Player]) -> Option<&Player> {
    players.iter().max_by_key(|p| p.score)
}

La mayoría de los editores pueden ejecutarlo cada vez que guardas. En VS Code, activa la opción “Format On Save”.

`cargo clippy`: una revisión de código amistosa

Clippy conoce cientos de patrones que son incorrectos, lentos o simplemente más difíciles de leer de lo necesario. Aquí tienes un programa pequeño que funciona bien:

fn main() {
    let tasks: Vec<&str> = vec!["escribir la documentación", "corregir un bug"];

    if tasks.len() == 0 {
        println!("¡Nada que hacer!");
    } else {
        println!("{} tareas pendientes", tasks.len());
    }
}

Pero cargo clippy tiene una sugerencia:

warning: length comparison to zero
 --> src/main.rs:4:8
  |
4 |     if tasks.len() == 0 {
  |        ^^^^^^^^^^^^^^^^ help: using `is_empty` is clearer and more explicit: `tasks.is_empty()`
  |
  = note: `#[warn(clippy::len_zero)]` on by default

Clippy te dice que comparar la longitud con cero se lee mejor como tasks.is_empty(). Cada aviso tiene un nombre (aquí len_zero) que puedes buscar en la lista de lints de Clippy (en inglés) para leer una explicación más larga. Esta es la versión corregida:

fn main() {
    let tasks: Vec<&str> = vec!["escribir la documentación", "corregir un bug"];

    if tasks.is_empty() {
        println!("¡Nada que hacer!");
    } else {
        println!("{} tareas pendientes", tasks.len());
    }
}

Salida:

2 tareas pendientes

▶ Pruébalo tú mismo

cargo clippy --fix puede aplicar muchas sugerencias por ti. Clippy no siempre acierta para tu caso, pero acierta tantas veces que leer cada aviso es una forma rápida de aprender Rust idiomático.

Herramientas extra de cargo muy útiles

Cualquiera puede añadir subcomandos nuevos a cargo. Los instalas con cargo install, que descarga el código fuente, lo compila y pone el programa en ~/.cargo/bin (en Windows, %USERPROFILE%\.cargo\bin). No necesitas ninguno el primer día, pero vale la pena conocerlos:

Herramienta	Qué hace	Instalar	Ejecutar
bacon	Vuelve a ejecutar check, clippy o los tests cada vez que guardas, en una terminal aparte	`cargo install --locked bacon`	`bacon`, `bacon clippy`, `bacon test`
cargo-watch	Ejecuta cualquier comando de cargo al guardar. Sigue funcionando, pero ya no se actualiza; su autor recomienda bacon	`cargo install --locked cargo-watch`	`cargo watch -x check`
cargo-nextest	Un ejecutor de tests más rápido y con una salida más clara	`cargo install --locked cargo-nextest`	`cargo nextest run`
cargo-audit	Compara tu `Cargo.lock` con los avisos de seguridad conocidos	`cargo install cargo-audit`	`cargo audit`
cargo-outdated	Lista las dependencias que tienen versiones más nuevas	`cargo install --locked cargo-outdated`	`cargo outdated`
cargo-edit	Añade `cargo upgrade`, que sube las versiones en `Cargo.toml` (`cargo add` ya viene incluido)	`cargo install cargo-edit`	`cargo upgrade`
cargo-expand	Muestra el código en el que se convierten tus macros y tus `#[derive]`	`cargo install cargo-expand`	`cargo expand`
cargo-binstall	Descarga binarios ya compilados en lugar de compilar, así que las instalaciones tardan segundos	`cargo install cargo-binstall`	`cargo binstall bacon`

cargo install compila desde el código fuente, así que la primera instalación de una herramienta grande puede tardar unos minutos. Es normal. Para actualizar una herramienta más adelante, vuelve a ejecutar el mismo comando de instalación. Para ver lo que tienes instalado, ejecuta cargo install --list. Para herramientas centradas en la velocidad, como profilers y benchmarks, consulta Rendimiento.

Sin instalar nada: el Rust Playground

El Rust Playground ejecuta Rust en tu navegador. Cada botón “Pruébalo tú mismo” de este sitio lo abre. Es perfecto para experimentos rápidos, para compartir un fragmento de código cuando pides ayuda o para aprender en un ordenador donde no puedes instalar nada.

Lo que sí puede hacer:

Ejecutar tu código en stable, beta o nightly, como compilación debug o release.
Usar los 100 crates más descargados de crates.io (más los crates que usa el Rust Cookbook y sus dependencias), como serde, rand, regex y tokio.
Ejecutar rustfmt y Clippy desde el menú Tools.
Compartir tu código como un enlace.

Lo que no puede hacer:

Tener más de un archivo. No hay Cargo.toml, así que no puedes elegir otros crates ni otras versiones.
Acceder a la red. El código que descarga una página web fallará.
Trabajar con tus propios archivos, ni ejecutarse durante mucho tiempo. El tiempo y la memoria son limitados.
Ser cómodo para programas interactivos. Mientras un programa se ejecuta, aparece una pequeña caja donde puedes escribir la entrada, pero resulta incómoda para algo más que una prueba rápida. Los ejemplos de este sitio nunca leen la entrada, así que se ejecutan con un solo clic.

Cuando se te quede pequeño, un proyecto local con cargo new está a solo un minuto.

Lista de comprobación para un ordenador nuevo

¿Vas a configurar un ordenador nuevo? Repasa esta lista una vez:

Instala los requisitos de tu sistema operativo: las herramientas de C++ de Visual Studio (Windows), xcode-select --install (macOS) o build-essential / gcc (Linux).
Instala Rust desde rustup.rs y luego abre una terminal nueva.
Compruébalo: rustc --version y cargo --version.
Asegúrate de que tienes las herramientas de cada día: rustup component add clippy rustfmt.
Instala un editor con rust-analyzer. Con VS Code, añade las extensiones rust-analyzer y CodeLLDB.
Activa el formateo al guardar en tu editor.
Crea un proyecto de prueba con cargo new hello y ejecuta dentro cargo run, cargo clippy y cargo fmt.
Ponte un recordatorio para ejecutar rustup update cada uno o dos meses.
Opcional: cargo install --locked bacon para tener respuesta instantánea mientras programas.

Práctica

1. Revisa tu caja de herramientas

En tu propio ordenador, ejecuta cada uno de estos comandos y asegúrate de que ninguno dice “not installed”: rustup show, cargo clippy --version, cargo fmt --version. Después abre la documentación de la biblioteca estándar sin conexión y busca la página de Vec. Pista: rustup doc acepta un tema, como la ruta completa de un tipo.

Ver solución

rustup show
cargo clippy --version
cargo fmt --version
rustup doc std::vec::Vec

Cada comando --version imprime un número de versión. Si alguno imprime un error en su lugar, instala la pieza que falta con rustup component add clippy o rustup component add rustfmt. El último comando abre la página de Vec en tu navegador, directamente desde tu disco. Si dice que rust-docs no está instalado, ejecuta antes rustup component add rust-docs.

2. Deja que Clippy te enseñe

En un proyecto nuevo, pega en src/main.rs la primera versión del programa de tareas de la sección de Clippy. Ejecuta cargo clippy, lee el aviso y luego deja que Clippy lo arregle por ti. Pista: hay una opción que aplica las sugerencias automáticamente.

Ver solución

cargo new task_queue
cd task_queue
# pega el programa en src/main.rs, y luego:
cargo clippy
cargo clippy --fix --allow-dirty
cargo clippy

El primer cargo clippy muestra el aviso len_zero. cargo clippy --fix reescribe tasks.len() == 0 como tasks.is_empty(). La opción --allow-dirty le permite modificar archivos que todavía no has guardado en un commit de git. La última ejecución no muestra ningún aviso.

Resumen

rustup instala y actualiza Rust y cambia de toolchain; cargo compila, ejecuta, prueba y añade crates; rustc es el compilador que trabaja por debajo.
Cada sistema operativo necesita primero un linker: las herramientas de C++ de Visual Studio en Windows, xcode-select --install en macOS, build-essential o gcc en Linux.
Quédate en stable. Usa rust-toolchain.toml solo cuando un proyecto deba fijar una versión, y cargo +nightly para comandos sueltos con nightly.
Usa un editor con rust-analyzer. VS Code con rust-analyzer y CodeLLDB es la configuración más común.
Ejecuta cargo check a menudo, y cargo fmt más cargo clippy antes de cada commit. Usa dbg! para echar un vistazo rápido y un depurador para los errores más difíciles.
El Playground es genial para experimentar y compartir, pero solo tiene un archivo, no tiene red y solo ofrece los crates más populares.

Comprueba lo que aprendiste

Comprueba lo aprendido

1. ¿Qué herramienta usarías para instalar la toolchain nightly junto a stable?

2. Tu compilación en Windows falla porque no se encuentra ningún linker. ¿Qué es lo que más probablemente falta?

3. ¿Dónde imprime dbg! su salida?

4. ¿Cuál de estas cosas NO puede hacer el Rust Playground?

Puntuación: 0 / 4

Para leer más

Instalar Rust — rust-lang.org: el instalador oficial para cada plataforma, con notas sobre Windows, el PATH y cómo desinstalar.
The rustup book (en inglés): toolchains, canales, componentes, perfiles, rust-toolchain.toml y targets para compilación cruzada.
The Cargo Book (en inglés): todo sobre cargo, incluido cargo install y las opciones de cada comando.
Manual de rust-analyzer (en inglés): cómo configurar rust-analyzer en VS Code, Neovim, Helix, Emacs y otros editores, y todas sus opciones.
Documentación de Clippy (en inglés): cómo ejecutar y configurar Clippy, con un enlace a la lista completa de lints y lo que significa cada uno.