Aprende las bases de Rust, el lenguaje de programación utilizado en Solana.
Aunque en Solana podemos interactuar con programas desde TypeScript, la mayor parte del desarrollo on-chain se escribe en Rust (especialmente cuando usamos Anchor). Aprender Rust te da la base para entender cómo se construyen programas seguros y eficientes, y te prepara para leer, modificar y auditar código real del ecosistema.
Programando en Rust
Para este bootcamp, la parte práctica de Rust (sintaxis y fundamentos) la trabajaremos con el repositorio Learning Rust, que funciona como guía progresiva con ejemplos y ejercicios. Ahí verás desde una introducción general y comandos básicos de terminal, hasta los pilares del lenguaje que necesitaremos para Solana: tipos de variables, control de flujo, funciones, ownership, colecciones, y estructuras como structs y enums.
La idea es que este GitBook te dé el contexto teórico y referencias, mientras que el repositorio te ofrece la práctica guiada para consolidar lo aprendido.
Rust vs otros lenguajes (en el contexto de blockchain)
Rust suele compararse con lenguajes como JavaScript/Python (más rápidos para prototipar) y con C/C++ (muy eficientes pero con más riesgos de errores de memoria). La diferencia clave es que Rust busca ofrecer performance de “nivel sistema” (cercano a C/C++) pero con un enfoque fuerte en seguridad: te obliga a manejar explícitamente temas como ownership y mutabilidad para evitar clases enteras de bugs comunes.
En blockchain esto importa mucho, porque un error no solo “crashea” un programa: puede significar pérdida de fondos o fallas de seguridad. Por eso Rust se volvió una opción muy popular para infra crítica y, en el caso de Solana, para programas on-chain.
Solana fue diseñada para aplicaciones de alta demanda (DeFi, pagos, gaming), donde necesitas baja latencia y alto rendimiento. Rust encaja muy bien con ese objetivo porque permite escribir código eficiente y predecible, y además tiene un ecosistema maduro para construir librerías reutilizables.
En la práctica, cuando desarrollas en Solana, tus programas se apoyan en el crate solana-program, que funciona como la “base” para escribir programas que corren en la red. Y cuando usas Anchor, Rust sigue siendo el lenguaje del programa, solo que con herramientas que reducen boilerplate y mejoran la experiencia del desarrollador.
Seguridad y performance: el “trade-off” que Rust resuelve
Muchos lenguajes te obligan a escoger entre:
seguridad y facilidad (ej. Python/JS), o
control y performance (ej. C/C++).
Rust intenta darte ambos: un modelo que reduce errores comunes de memoria (como use-after-free o data races) sin depender de un garbage collector tradicional. En un entorno como blockchain —donde los programas deben ser confiables, auditables y eficientes— esto es una ventaja enorme.
Dicho simple: Rust te ayuda a escribir programas que fallan menos y corren rápido, que es justo lo que queremos cuando el código vive “en producción” desde el momento en que lo despliegas.
Compilación vs ejecución interpretada (por qué importa aquí)
Una forma útil de entenderlo:
Lenguajes interpretados (mucho JavaScript/Python en la práctica): suelen ejecutarse a través de un “runtime” que interpreta o JIT-compila, lo cual acelera el desarrollo, pero puede introducir variaciones de performance y dependencia del entorno.
Lenguajes compilados como Rust: se traducen a código máquina (o a un formato objetivo) antes de ejecutarse, lo que suele dar mejor performance y resultados más consistentes.
En Solana, esto se vuelve muy relevante porque los programas que se ejecutan en la red necesitan ser determinísticos (mismo input → mismo output) y eficientes. Por eso el flujo típico incluye compilar tu programa (local o en Playground), desplegarlo y luego interactuar con él mediante transacciones.
Ownership y Borrowing (lo esencial para Solana)
Uno de los conceptos más importantes de Rust —y también una de las razones por las que es tan seguro— es su modelo de ownership (propiedad). En Rust, cada valor en memoria tiene un “dueño” (una variable) responsable de su ciclo de vida. Cuando ese dueño sale de alcance (scope), Rust libera automáticamente la memoria, evitando fugas y errores comunes sin necesidad de un garbage collector.
A partir de ownership, Rust introduce el borrowing (préstamo): en lugar de mover/copiar valores todo el tiempo, puedes “prestar” una referencia a una función o a otra parte del código. Hay dos tipos principales:
Referencias inmutables (&T): puedes tener muchas al mismo tiempo, mientras nadie modifique el valor.
Referencias mutables (&mut T): solo puede existir una a la vez, y mientras exista no pueden coexistir referencias inmutables.
Estas reglas evitan data races y muchos bugs de concurrencia en tiempo de compilación, antes de ejecutar el programa. En el contexto de Solana, esto es muy útil porque los programas on-chain deben ser altamente confiables: la red ejecuta tu código miles de veces y cualquier error puede volverse costoso. Por eso, entender ownership y borrowing no es solo “teoría de Rust”, sino una habilidad directa para escribir programas seguros y correctos.
