Avatar de h1dr0 El Rincon del Tech blog de h1dr0
Sígueme
← Volver

Rust desde cero: guía para principiantes en 5 pasos

26 de septiembre de 2026
rust programación tutorial desarrollo de software cargo rustup hello world
Rust desde cero: guía para principiantes en 5 pasos

Rust desde cero: guía completa en 5 capítulos

Si estás leyendo esto, probablemente has oído hablar de Rust más de una vez. Quizás en un foro, quizás en el trabajo, quizás porque alguien te dijo que es "el lenguaje del futuro" y te quedaste con la duda. Sea como sea, has llegado al sitio correcto: esta guía te llevará de la mano desde cero absoluto hasta tener tu primer programa funcionando y un plan claro para seguir avanzando.

No voy a asumir que sabes nada de Rust. Solo necesitas ganas de aprender y un ordenador delante. Al final de cada capítulo te dejaré un pequeño gancho para que sigas leyendo, porque esto está pensado para leerse como una historia: ¿qué es Rust?, ¿cómo se instala?, ¿cómo preparo mi editor?, ¿cómo escribo mi primer programa? y ¿qué hago después?

¿Vamos allá?

Capítulo 1: ¿Qué es Rust y por qué aprenderlo?

Un poco de historia

Rust no nació en un laboratorio gigante ni como producto comercial de una gran corporación. Empezó en 2006 como un proyecto personal de Graydon Hoare, un desarrollador que quería construir un lenguaje de sistemas que no le hiciera sufrir con los errores clásicos de C y C++: punteros que apuntan a memoria ya liberada, fugas de memoria imposibles de rastrear, condiciones de carrera que solo aparecen en producción un viernes por la noche.

La cosa cambió cuando Mozilla se interesó por el proyecto y decidió patrocinarlo. Con ese respaldo, lo que era el experimento de una persona se convirtió en un esfuerzo serio y sostenido. Rust maduró durante años, con una comunidad creciente alrededor, hasta alcanzar un hito fundamental: la versión 1.0 se publicó el 15 de mayo de 2015.

Ese 1.0 no fue solo un número: fue una promesa de estabilidad. Desde ese día, el código que escribes en Rust estable seguirá compilando en el futuro. Eso puede sonar obvio si vienes de otros mundos, pero para un lenguaje joven fue una declaración de intenciones: Rust quería ser una herramienta de producción, no un juguete de investigación.

La filosofía: rápido y seguro a la vez

Aquí viene lo realmente interesante. Tradicionalmente, el mundo de la programación te obligaba a elegir un bando:

Rust mira esa disyuntiva y dice: ¿por qué elegir? Su filosofía se resume en una frase que deberías tatuarte mentalmente: velocidad y eficiencia de memoria sin garbage collector.

¿Y cómo consigue ese milagro? Con su característica estrella: el modelo de ownership (propiedad).

El ownership es un conjunto de reglas que el compilador verifica en tiempo de compilación, antes de que tu programa siquiera exista como ejecutable. La idea central es simple de enunciar: cada valor en memoria tiene un único dueño, y cuando ese dueño sale de ámbito, la memoria se libera automáticamente. No hay un recolector de basura vigilando en segundo plano, no hay pausas impredecibles, no hay sorpresas en producción. La limpieza ocurre en momentos que el compilador conoce con total precisión.

Y aquí viene el regalo que se esconde dentro: este mismo modelo garantiza seguridad de memoria y de hilos. Los temidos data races —esos bugs donde dos hilos pisan los mismos datos a la vez— simplemente no compilan en Rust. El compilador los detecta y te obliga a resolverlos antes de ejecutar nada.

Por eso se dice que el compilador de Rust es "exigente". Y lo es, no te voy a mentir: tus primeras semanas discutirás con él. Pero es como ese profesor estricto del colegio que al final del curso te das cuenta de que te salvó la vida. Cada error que te señala en tu pantalla es un bug que no llegará a producción.

Un ejemplo para entender la idea

Imagina que la memoria de tu programa es un piso compartido. En los lenguajes clásicos de sistemas, cualquier inquilino podía entrar a cualquier habitación en cualquier momento: el resultado eran accidentes constantes. En los lenguajes con garbage collector, hay un conserje que recorre el piso de vez en cuando recogiendo lo que nadie usa — cómodo, pero el conserje interrumpe la vida del piso cada cierto tiempo.

En Rust, el contrato de alquiler es distinto: cada habitación tiene un único inquilino responsable en cada momento. Puedes prestar tu habitación bajo reglas muy estrictas (el famoso borrowing), pero cuando tu contrato termina, la habitación se libera de inmediato y de forma predecible. Sin conserje, sin accidentes, sin pausas. Esa es, en esencia, la idea del ownership: convertir errores que antes explotaban en ejecución en avisos claros durante la compilación.

¿Para qué se usa Rust en el mundo real?

Quizás pienses: "muy bonito todo, pero ¿esto sirve para algo real?". La respuesta es un sí rotundo. Rust ya no es un experimento académico; hoy se usa en ámbitos muy diversos:

Piénsalo un momento: el mismo lenguaje sirve para escribir una herramienta de terminal, una aplicación web de alto rendimiento y partes de dos de los sistemas operativos más importantes del planeta. Ese es el rango de Rust.

Y no son casos aislados ni proyectos de laboratorio: cientos de empresas usan Rust en producción hoy en día, confiándole partes críticas de su infraestructura.

El lenguaje más querido

Si los argumentos técnicos no acaban de convencerte, quizás lo haga la gente que ya lo usa: Rust ha sido elegido el lenguaje "más admirado" en las encuestas de Stack Overflow durante años consecutivos. No es una moda pasajera ni un año de suerte: es una tendencia sostenida que dice algo muy claro — la gente que prueba Rust, se queda.

¿Listo para probarlo tú? En el siguiente capítulo dejamos tu máquina preparada en cuestión de minutos, sea cual sea tu sistema operativo.

Capítulo 2: Instalación de Rust

Rustup: tu mejor amigo desde el primer día

Antes de escribir una sola línea de código, necesitamos instalar las herramientas. Y aquí viene la primera buena noticia del día: la forma oficial y recomendada de instalar Rust es mediante rustup, una pequeña herramienta que se encarga de descargar, instalar y gestionar las versiones del compilador y sus componentes.

¿Por qué rustup y no el gestor de paquetes de tu sistema? Porque Rust evoluciona con regularidad, y rustup te permite mantenerte al día sin fricción, cambiar entre versiones si lo necesitas y añadir componentes extra con un comando. Olvídate de apt, brew o instaladores sueltos: rustup es el camino, y te acompañará todo el tiempo que uses Rust.

Instalación en macOS y Linux

Abre una terminal y ejecuta este comando:

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

Vamos por partes, porque pegar comandos de internet sin entenderlos nunca es buena idea: curl descarga el script de instalación desde la web oficial de rustup, forzando conexión HTTPS y TLS 1.2 o superior, y el | sh final ejecuta ese script directamente.

El instalador te hará unas preguntas sencillas. Si no tienes necesidades especiales, la opción por defecto es la correcta: pulsa Enter y deja que trabaje. En uno o dos minutos tendrás todo instalado.

Un detalle importante: rustup instala las herramientas en el directorio ~/.cargo y prepara la configuración del PATH a través del archivo ~/.cargo/env. ¿Qué significa esto en la práctica? Que cuando abras una terminal nueva, los comandos rustc y cargo estarán disponibles automáticamente. Si quieres usarlos ya en la terminal que tienes abierta, carga esa configuración manualmente:

source ~/.cargo/env

Instalación en Windows

En Windows el proceso es igual de sencillo, pero hay un requisito previo importante que no debes saltarte: necesitas tener instaladas las Visual Studio Build Tools con la carga de trabajo de C++. Rust las necesita para compilar y enlazar tus programas; sin ellas, el compilador no podrá generar ejecutables y te encontrarás con errores confusos. Así que primero las Build Tools, luego Rust.

Una vez cubierto ese requisito, descarga rustup-init.exe (la versión de 64 bits) desde la web oficial de Rust y ejecútalo como cualquier instalador de Windows. El asistente te hará un par de preguntas, aceptas las opciones por defecto y listo.

Verifica que todo funciona

Sea cual sea tu sistema operativo, el ritual de verificación es el mismo. Ejecuta estos tres comandos:

rustc --version
cargo --version
rustup --version

Cada uno comprueba una pieza distinta del ecosistema:

Si los tres responden con un número de versión en lugar de un error de "comando no encontrado", enhorabuena: tienes Rust instalado. Para que tengas una referencia, a día de hoy la versión estable actual es Rust 1.98.1 (septiembre de 2026). Si tu rustc --version muestra ese número o uno cercano, vas perfecto.

Actualizar y desinstalar: dos comandos para recordar

Rust publica versiones nuevas de forma regular, y mantenerse al día no podría ser más simple:

rustup update

Ese único comando actualiza el compilador, Cargo y todos los componentes instalados. Nada de desinstalar y reinstalar: rustup update y a seguir programando.

Y si algún día decides que Rust no era para ti (no pasa nada, no te guardaré rencor), la desinstalación es igual de limpia:

rustup self uninstall

Eso elimina el compilador, las herramientas y la configuración del PATH, dejando tu sistema como estaba.

¿Qué se ha instalado exactamente?

Para que no quede como magia, un resumen rápido de lo que rustup ha dejado en tu máquina: el compilador (rustc), la herramienta de construcción (cargo), el propio rustup para gestionar versiones, y utilidades extra como el formateador y el linter (que veremos en detalle en el capítulo 3). Todo vive bajo el directorio ~/.cargo en sistemas Unix, de forma ordenada y fácil de eliminar si algún día lo necesitas.

Si en algún momento un comando falla con un error del tipo "command not found" en macOS o Linux, sospecha primero del PATH: comprueba que el archivo ~/.cargo/env se está cargando en tu terminal, o ejecútalo a mano con source ~/.cargo/env. Es el pequeño tropiezo más común tras la instalación y se arregla en segundos.

Y con esto, la instalación ha terminado. Pero seamos sinceros: un compilador sin un buen editor es como un coche deportivo sin volante. En el próximo capítulo configuramos tu entorno de desarrollo para que escribir Rust sea, de verdad, un placer.

Capítulo 3: Configuración del entorno de desarrollo

VS Code + rust-analyzer: la combinación ganadora

Podrías escribir Rust en el Bloc de notas si te empeñas, pero la vida es corta. La opción más popular entre los desarrolladores Rust es Visual Studio Code combinado con la extensión rust-analyzer (la encontrarás en el marketplace con el ID rust-lang.rust-analyzer). Instala VS Code, abre la pestaña de extensiones, busca ese ID, pulsa instalar y... ya está. Sin configuración adicional.

A cambio de ese minuto de trabajo obtienes, desde el primer momento:

rust-analyzer es tan bueno que muchos desarrolladores afirman que es la mejor experiencia de IDE que existe en cualquier lenguaje de programación. No puedo confirmarlo científicamente, pero te aseguro que la primera vez que lo ves funcionar impresiona. Y es completamente gratis.

Alternativas para todos los gustos

Si VS Code no es lo tuyo, no te preocupes, tienes opciones estupendas:

Herramientas que ya tienes instaladas (y quizás no lo sabías)

Aquí viene otra buena noticia: cuando instalaste Rust con rustup en el capítulo anterior, no solo instalaste un compilador. Recibiste un kit completo de herramientas profesionales, sin descargar nada extra:

cargo fmt

y todo tu código queda formateado según el estilo oficial. Tus compañeros de equipo (y tu yo del futuro) te lo agradecerán.

cargo clippy

Y aquí va mi consejo personal de este capítulo: ejecuta cargo fmt y cargo clippy a menudo. Clippy no se limita a señalar: explica el porqué de cada sugerencia, con ejemplos y alternativas. Muchos desarrolladores (yo el primero) hemos aprendido buenas prácticas de Rust simplemente leyendo los mensajes de clippy. Es como tener un mentor paciente revisando cada una de tus líneas.

Depuración: porque los bugs no preguntan permiso

Tarde o temprano necesitarás depurar: poner un punto de interrupción, parar la ejecución y mirar qué demonios contiene esa variable. En VS Code tienes dos opciones habituales para ello: la extensión CodeLLDB o la extensión C/C++ de Microsoft. Ambas te dan la experiencia clásica de depuración: breakpoints, inspección de variables, ejecución paso a paso, pila de llamadas... todo lo que esperarías de cualquier lenguaje "serio".

Un flujo de trabajo diario recomendado

Antes de pasar de capítulo, te dejo cómo se ve un día normal de desarrollo en Rust con todo esto ya configurado, para que vayas interiorizando el ritmo: abres tu proyecto en el editor, escribes código mientras rust-analyzer te subraya los errores al vuelo, ejecutas cargo check o cargo run (los veremos en el próximo capítulo) para probar los cambios, y antes de dar por terminada la sesión pasas cargo fmt para dejar el código ordenado y cargo clippy para recibir sugerencias de mejora. Cuatro hábitos sencillos que, repetidos cada día, hacen que el código Rust sea notablemente uniforme de un proyecto a otro: si algún día lees el código de otra persona, te resultará familiar desde la primera línea.

Con el compilador instalado, el editor afilado y las herramientas listas, ya no queda ninguna excusa para procrastinar. Llega el momento solemne de todo aprendizaje de programación: escribir tu primer programa.

Capítulo 4: Hello World y tu primer proyecto con Cargo

Creando el proyecto: deja que Cargo trabaje

En muchos lenguajes, empezar un proyecto significa crear carpetas a mano, configurar herramientas de build y rezar. En Rust, todo eso se reduce a un comando:

cargo new hello_world

Este comando hace dos cosas por ti, y conviene que las sepas desde el principio: crea el proyecto con la estructura estándar de directorios e inicializa un repositorio git automáticamente. Tu código ya nace con control de versiones. Entra en el directorio recién creado:

cd hello_world

La estructura de directorios, pieza a pieza

Si listas el contenido, verás algo así:

hello_world/
├── Cargo.toml
└── src/
    └── main.rs

Vayamos pieza por pieza:

Tu primer programa

Cargo ya ha dejado código listo dentro de src/main.rs. Ábrelo con tu editor y encontrarás esto:

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

Tres líneas, pero con una lección importante escondida. Fíjate bien: es println! con signo de exclamación. Eso no es un adorno ni un grito de entusiasmo: significa que println! no es una función, es una macro. Las macros en Rust son código que genera código en tiempo de compilación, y siempre se distinguen visualmente por ese ! final. Las verás por todas partes en el ecosistema Rust, así que graba la regla mnemotécnica: si lleva exclamación, es una macro.

El Cargo.toml mínimo

Abre ahora el archivo Cargo.toml. Su contenido será prácticamente este:

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

[dependencies]

Dos cosas a comentar aquí. La línea edition = "2024" indica la edición de Rust que usa el proyecto. Las ediciones son el mecanismo que tiene Rust para introducir mejoras en el lenguaje sin romper el código antiguo: cada proyecto declara su edición y el compilador se comporta en consecuencia. Y la sección [dependencies], que ahora aparece vacía, es el lugar donde irás listando las librerías externas (los crates, como se llaman en Rust) que necesites. Cargo se encargará de descargarlas y compilarlas por ti.

Los cuatro comandos que usarás cada día

Vamos con la parte práctica de verdad. Estos cuatro comandos de Cargo serán tu pan de cada día, conviene dominarlos desde ya.

cargo check — Verifica que tu código compila, pero sin generar el ejecutable. Es el más rápido de todos, y por eso es tu mejor aliado mientras escribes: comprueba errores a velocidad de rayo.

cargo check

cargo build — Compila el proyecto y genera el ejecutable dentro del directorio target/debug/:

cargo build

cargo run — El comodín: compila el proyecto (solo si hay cambios desde la última vez) y lo ejecuta inmediatamente. Es el comando que más usarás durante el desarrollo:

cargo run

Si todo ha ido bien, verás el clásico saludo aparecer en tu terminal. Respira hondo: acabas de ejecutar tu primer programa en Rust.

cargo build --release — Compila el proyecto con todas las optimizaciones activadas, pensado para producción o distribución. El ejecutable resultante se guarda en target/release/:

cargo build --release

¿Y cuál es la diferencia práctica entre debug y release? El ejecutable de target/debug compila rápido pero corre más lento, porque no aplica optimizaciones e incluye información de depuración. El de target/release tarda más en compilarse, pero el binario resultante es mucho más rápido en ejecución. De ahí la regla de oro que usan todos los desarrolladores Rust: trabaja con cargo check y cargo run durante el desarrollo, y guarda cargo build --release para cuando quieras compartir o desplegar tu programa.

Experimenta antes de seguir

Antes de cerrar el capítulo, te propongo tres mini-ejercicios para asentar lo aprendido. Primero: modifica el mensaje de println! para que salude con tu nombre y vuelve a ejecutar cargo run. Segundo: borra a propósito el punto y coma final y ejecuta cargo check — lee con calma el mensaje de error del compilador, porque aprender a leerlos es media batalla en Rust (y verás que son sorprendentemente claros y amables). Tercero: compila con cargo build --release y explora las carpetas target/debug y target/release para ver dónde ha quedado cada ejecutable.

¿Notas algo curioso si repites cargo run dos veces seguidas sin tocar el código? La segunda vez compila al instante: Cargo detecta que nada ha cambiado y reutiliza lo que ya tenía. Este tipo de detalles hacen que el ciclo de desarrollo sea ágil incluso en proyectos grandes.

¡Felicidades! Tienes tu primer proyecto Rust creado, compilado y ejecutado, y entiendes la estructura que lo sostiene. Pero esto, créeme, es solo la punta del iceberg. En el último capítulo te dejo el mapa completo para seguir creciendo: libros, ejercicios, comunidad y una hoja de ruta clara.

Capítulo 5: Siguientes pasos

Has llegado al final de la guía, pero esto no es una despedida: es una entrega de llaves. A continuación tienes los mejores recursos para continuar, todos ellos gratuitos, y una ruta de aprendizaje sensata para no perderte por el camino.

Recursos imprescindibles (y gratuitos)

La comunidad: nunca programas solo

Rust tiene fama (merecida) de tener una de las comunidades más acogedoras del mundo del software. Aviso honesto: te vas a atascar. El borrow checker —la parte del compilador que vigila las reglas de ownership— no perdona, y todos hemos pasado horas mirando un mensaje de error. Cuando llegue ese momento, aquí te echarán una mano:

Hoja de ruta sugerida: ¿y ahora qué?

Aprender Rust tiene una curva de dificultad inicial algo más empinada que otros lenguajes, así que el orden en que abordas los temas importa. Esta es la secuencia que yo recomendaría:

  1. Ownership en profundidad. Es el corazón de Rust y no hay atajos: entiende bien la propiedad, el borrowing (préstamo) y las referencias antes que cualquier otra cosa. Todo lo demás se apoya en estos conceptos.
  2. Structs y enums. Los tipos de datos con los que modelarás tus programas. Los enums de Rust, combinados con match, son de las cosas más elegantes del lenguaje.
  3. Manejo de errores. Rust no usa excepciones: aprenderás a trabajar con Result y Option, y a hacer explícitos los errores en lugar de esconderlos.
  4. Traits. El sistema de "interfaces" de Rust, la llave para escribir código genérico y reutilizable.
  5. Colecciones. Vectores, HashMap, strings... las estructuras de datos que usarás todos los días.

Con esa base ya podrás lanzarte a proyectos propios, que es donde realmente se consolida el aprendizaje: una CLI pequeña, un reto de Exercism, lo que te motive. Y un par de consejos finales de método, que valen tanto como los recursos: combina teoría y práctica en cada semana (lee un capítulo del libro y resuelve sus ejercicios equivalentes en Rustlings), no te saltes el ownership aunque al principio frustre —todo lo demás se apoya en él—, y pregunta sin vergüenza en el foro o en Discord cuando te atasques; la comunidad de Rust ha construido buena parte de su fama precisamente tratando bien a quien empieza.

Conclusión

Hagamos balance de lo conseguido: ahora sabes qué es Rust, de dónde viene y por qué tanta gente lo considera el lenguaje más admirable del panorama; lo tienes instalado y actualizado en tu máquina; tu editor está configurado como el de un profesional; y ya has creado, compilado y ejecutado tu primer programa con Cargo.

Lo que viene ahora es lo más divertido de todo: escribir, romper, arreglar y repetir. El compilador será tu copiloto exigente —a veces exasperante, siempre honesto—, y cada mensaje de error que te muestre será una lección gratuita sobre cómo escribir software más seguro. Dentro de unos meses mirarás atrás y te sorprenderá lo natural que te resulta todo esto.

La comunidad te espera con los brazos abiertos. Nos vemos por los foros. ¡A compilar!