1. Cadena de herramientas y Cargo

Las tres herramientas

Rust	Función	C#	Java
rustup	instala y actualiza las cadenas de herramientas	instalador del SDK de .NET / global.json	SDKMAN!, instaladores del JDK
cargo	compilar, ejecutar, probar, añadir dependencias	CLI de dotnet	Maven / Gradle
crates.io	registro público de paquetes	NuGet	Maven Central
rustc	el compilador (Cargo lo invoca por ti)	Roslyn (csc)	javac

Instalación

Rust se instala con rustup en todos los sistemas operativos. Rust usa el enlazador (linker) de la plataforma, así que cada sistema necesita también sus herramientas nativas de compilación de C.

Windows

winget install Rustlang.Rustup

O descarga rustup-init.exe desde rustup.rs. La cadena de herramientas predeterminada apunta a MSVC, así que también necesitas las Visual Studio C++ Build Tools (el enlazador); rustup-init ofrece instalarlas si faltan. Después, abre una terminal nueva para que cargo esté en el PATH.

Linux / WSL

sudo apt install build-essential        # el enlazador de C (Debian/Ubuntu; si no, el paquete de tu distribución)
curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh
. "$HOME/.cargo/env"                    # o abre un shell nuevo

En WSL, instala Rust dentro de la distribución Linux, no con el instalador de Windows, y guarda tus proyectos en el sistema de archivos de Linux (~/src/...), no bajo /mnt/c: ahí las compilaciones son mucho más rápidas. VS Code y RustRover pueden abrir directamente una carpeta de WSL.

macOS

xcode-select --install                  # las herramientas de línea de comandos de Apple, que incluyen el enlazador
curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh
. "$HOME/.cargo/env"                    # o abre una terminal nueva

Después, en cualquier sistema:

rustc --version   # rustc 1.94.0 (4a4ef493e 2026-03-02)
cargo --version   # cargo 1.94.0 (85eff7c80 2026-01-15)
rustup update     # actualizar a la última versión estable

Ningún runtime que instalar

Rust compila a un ejecutable nativo. No hay CLR ni JVM que distribuir: la compilación release de «Hello, world!» es un único archivo, de unos 130 KB como .exe en Windows y de unos 430–460 KB en macOS y Linux (medido por la CI del curso).

Crear un proyecto

cargo new hello
cd hello
cargo run

Windows

    Creating binary (application) `hello` package
   Compiling hello v0.1.0 (…\hello)
    Finished `dev` profile [unoptimized + debuginfo] target(s) in 1.01s
     Running `target\debug\hello.exe`
Hello, world!

Linux / WSL

    Creating binary (application) `hello` package
note: see more `Cargo.toml` keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
   Compiling hello v0.1.0 (…/hello)
    Finished `dev` profile [unoptimized + debuginfo] target(s) in 0.55s
     Running `target/debug/hello`
Hello, world!

macOS

    Creating binary (application) `hello` package
note: see more `Cargo.toml` keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
   Compiling hello v0.1.0 (…/hello)
    Finished `dev` profile [unoptimized + debuginfo] target(s) in 3.89s
     Running `target/debug/hello`
Hello, world!

Las salidas de Linux y macOS provienen de los runners de la CI del curso, que usan un Cargo más reciente que añade la línea note:.

cargo new también ejecuta git init y escribe un .gitignore. La estructura:

hello/
├── Cargo.toml      ← like .csproj or pom.xml
├── src/
│   └── main.rs     ← entry point (a library would have src/lib.rs)
└── .gitignore

Cargo.toml

[package]
name = "hello"
version = "0.1.0"
edition = "2024"

[dependencies]

src/main.rs

fn main() {
    println!("Hello, world!");
}

• println! termina en ! porque es una macro, no una función (comprueba la cadena de formato en tiempo de compilación).
• La edición (2024) es como <LangVersion> o --release: activa cambios del lenguaje sin romper los crates más antiguos, que siguen compilando con su propia edición.

Las salidas de este curso

Los errores del compilador y las salidas de los programas de las lecciones se capturaron en Windows. En Linux y macOS son idénticos salvo por las rutas: / en lugar de \, y sin extensión .exe ni .dll. La CI del curso también compila y ejecuta cada ejemplo en Linux y macOS.

Comandos del día a día

Tarea	Cargo	dotnet	Maven
Nueva aplicación	cargo new app	dotnet new console	mvn archetype:generate
Nueva biblioteca	cargo new --lib lib	dotnet new classlib	—
Comprobación rápida de tipos	cargo check	—	—
Compilar (debug)	cargo build	dotnet build	mvn compile
Compilar (release)	cargo build --release	dotnet build -c Release	mvn package
Ejecutar	cargo run	dotnet run	mvn exec:java
Probar	cargo test	dotnet test	mvn test
Añadir una dependencia	cargo add rand	dotnet add package	editar pom.xml
Formatear	cargo fmt	dotnet format	plugin Spotless
Análisis estático (lint)	cargo clippy	analizadores de Roslyn	Error Prone, SpotBugs
Documentación de la API	cargo doc --open	documentación XML + DocFX	javadoc

Usa cargo check todo el tiempo

cargo check ejecuta toda la comprobación de tipos y el borrow checker, pero se salta la generación de código. Es mucho más rápido que una compilación, y es lo que hace tu editor (rust-analyzer) con cada pulsación de tecla.

Dependencias

cargo add rand

[dependencies]
rand = "0.10.2"

• "0.10.2" significa compatible con 0.10.2 (caret de SemVer), no «exactamente 0.10.2».
• Las versiones exactas resueltas se escriben en Cargo.lock — como packages.lock.json o un archivo de bloqueo de Gradle. Súbelo al control de versiones en las aplicaciones.
• Las compilaciones debug y release van a target/debug y target/release (como bin/Debug y bin/Release).

Puntos clave

• rustup gestiona los compiladores, cargo hace todo lo demás y crates.io aloja los paquetes.
• Cada sistema necesita su enlazador nativo: Visual Studio Build Tools, build-essential o las herramientas de línea de comandos de Xcode.
• Cargo.toml + Cargo.lock ≈ .csproj + archivo de bloqueo / pom.xml.
• cargo check para una respuesta rápida, cargo build --release para binarios optimizados.

Ejercicios

1. Crea un proyecto llamado dice, añade el crate rand y busca en Cargo.lock qué versión se resolvió realmente.

Solución

Windows

cargo new dice
cd dice
cargo add rand
cargo build
Select-String -Path Cargo.lock -Pattern 'name = "rand"' -Context 0,1

Linux / WSL

cargo new dice
cd dice
cargo add rand
cargo build
grep -A1 'name = "rand"' Cargo.lock

macOS

cargo new dice
cd dice
cargo add rand
cargo build
grep -A1 'name = "rand"' Cargo.lock

Cargo.toml contiene el requisito que pediste; Cargo.lock contiene la versión exacta (y cada dependencia transitiva) que se eligió.

2. ¿Cuál es la diferencia entre cargo check y cargo build, y cuándo usarías cada uno?

Solución

cargo check comprueba los tipos y los préstamos sin producir un binario, así que es rápido — úsalo mientras editas. cargo build además genera código máquina — úsalo cuando necesites ejecutar el programa, y cargo build --release para una versión optimizada.

Fuentes

• The Book, ch. 1 — Getting Started
• rustup — Instalación y otros métodos de instalación
• The Cargo Book — Specifying dependencies
• The Rust Edition Guide
• Microsoft — Entorno de desarrollo de Rust en WSL