Scratchpad · Gratis

Escribe y ejecuta Rust en segundos

Scratchpad es el modo gratis: un solo archivo .rs, la biblioteca std y un set curado de crates estándar, con compilación y ejecución completas en tu iPad. Sin Cargo.toml, sin gestión de paquetes — solo escribe y pulsa Run. Es la forma más rápida de probar una idea, y el mismo motor que impulsa los tutoriales interactivos «Aprende Rust».

Para qué sirve Scratchpad

Scratchpad está pensado para el momento en que solo quieres probar algo: una característica del lenguaje, un algoritmo, un cálculo rápido, o un snippet que encontraste y quieres entender. No hay proyecto que configurar ni nada que instalar — el rustc real corre dentro de un sandbox wasm en tu dispositivo, así que obtienes errores de compilador de verdad, panics reales y salida real, no una aproximación.

• Un archivo — un solo main.rs, sin carpetas, sin manifiesto.
• std completo — colecciones, iteradores, formato, E/S, todo lo que te da la biblioteca estándar.
• Crates curados — un set incluido de crates estándar populares, listos sin ningún paso de dependencias.
• Ejecución instantánea — un botón compila y ejecuta, la salida aparece en la consola de abajo.

El editor, Run y la consola

Un scratchpad son tres cosas apiladas: un editor arriba, un botón Run, y una consola debajo. Escribes en el editor, pulsas Run, y la salida —incluidos panics y todo lo que vaya a stderr— aparece en la consola de abajo. No hay nada más que gestionar: sin ajustes de build, sin terminal, sin archivos que guardar a mano.

• Resaltado de sintaxis — palabras clave, cadenas y tipos se colorean mientras escribes, afinado para leer en una tableta.
• Autocompletado — sugerencias para elementos de std y los crates incluidos mientras escribes.
• Diagnósticos reales — la consola muestra los errores reales de rustc, con los mismos spans y sugerencias que en escritorio.
• Sin conexión — todo corre en el dispositivo, así que un scratchpad funciona en un avión sin señal.

Si emparejas un teclado físico con tu iPad, funcionan los atajos de edición habituales —seleccionar, copiar, pegar, deshacer y rehacer— y Run está a un toque en la barra de herramientas. El resultado es un ciclo lo bastante apretado para probar una idea en segundos y desecharla igual de rápido.

Tu primer programa

1. Abre un scratchpad

   Abre Ferric y crea un nuevo scratchpad. Obtienes un archivo, main.rs, listo para editar — sin configurar ningún proyecto.

2. Escribe Rust estándar

   Usa toda la biblioteca std y los crates curados que vienen incluidos. El resaltado de sintaxis y el autocompletado te ayudan mientras escribes.

3. Pulsa Run

   Ferric compila con el rustc real y ejecuta tu programa. La salida —incluidos panics y stderr— aparece en la consola bajo el editor.

4. Lee los errores, itera

   Los diagnósticos del compilador son los de verdad, con los mismos mensajes y sugerencias que verías en escritorio. Corrige, ejecuta de nuevo, repite.

fn main() {
    let names = ["Fe", "C", "P"];
    for (i, n) in names.iter().enumerate() {
        println!("{i}: hola desde {n}");
    }
}

Más allá del hola mundo

Como tienes toda la biblioteca estándar, Scratchpad hace mucho más que imprimir texto. Iteradores, clausuras, coincidencia de patrones, genéricos, manejo de errores con Result — todo compila y corre igual que en cualquier otro lado. Aquí un ejemplo un poco mayor que pliega unos números y formatea el resultado.

fn media(xs: &[f64]) -> Option<f64> {
    if xs.is_empty() { return None; }
    let suma: f64 = xs.iter().sum();
    Some(suma / xs.len() as f64)
}

fn main() {
    let datos = [12.0, 7.5, 9.0, 21.0, 4.5];
    match media(&datos) {
        Some(m) => println!("media = {m:.2}"),
        None    => println!("sin datos"),
    }
}

Define tus propios tipos

Un scratchpad no se limita a funciones sueltas. Declara structs y enums, dales métodos con impl, deriva traits como Debug o Clone — es Rust normal, así que todo lo que el lenguaje permita en un solo archivo funciona aquí.

#[derive(Debug)]
struct Contador { n: u32 }

impl Contador {
    fn nuevo() -> Self { Self { n: 0 } }
    fn sube(&mut self) { self.n += 1; }
}

fn main() {
    let mut c = Contador::nuevo();
    c.sube();
    c.sube();
    println!("{c:?}");
}

Escribe un test

Los tests unitarios también funcionan. Anota una función con #[test] y usa assert_eq!; Ferric compila y ejecuta los tests en el dispositivo y reporta cuáles pasaron. Es una forma sin fricción de comprobar que entendiste un rincón del lenguaje.

fn doble(x: i32) -> i32 { x * 2 }

#[test]
fn doble_de_21() {
    assert_eq!(doble(21), 42);
}

Los panics también son reales

Cuando algo sale mal en tiempo de ejecución —un índice fuera de rango, un unwrap sobre None— obtienes el mensaje y la ubicación reales del panic en la consola, exactamente como en escritorio. Esa fidelidad es todo el punto: lo que aprendes aquí se traslada directo a un toolchain de Rust completo.

El set de crates curados

Más allá de std, un scratchpad incluye un set fijo y curado de crates estándar populares para que tareas comunes —aleatoriedad, iteración más rica, manejo del tiempo— no necesiten ninguna configuración. No hay paso de dependencias: los crates ya están ahí, listos para usarse en cuanto escribes un use. Este set viene elegido y empaquetado con la app; en Scratchpad no puedes añadir dependencias arbitrarias de crates.io.

• Utilidades curadas para el día a día: aleatoriedad, adaptadores de iterador extra y utilidades de tiempo, entre otras.
• Cero configuración — sin Cargo.toml, sin versión que fijar, sin espera de vendorizado.
• ¿Necesitas en cambio un crate concreto de crates.io? Para eso está justo Pro.

Un curso entero, gratis

Scratchpad también impulsa «Aprende Rust», el curso interactivo incluido gratis en la app — más de 45 lecciones y 100 pasos que van de novato a experto, en español e inglés. Cada paso se compila y ejecuta con el rustc real de tu iPad, con pistas, solución y progreso guardado.

• Fundamentos, ownership, traits, lifetimes y concurrencia, paso a paso.
• Proyectos guiados que construyen algo real, más retos de «arregla el error» tomados de salida real del compilador.
• Un track embebido para la Raspberry Pi Pico cuyo LED verificas en un emulador integrado — sin hardware para aprender.

A dónde seguir

Ferric compila y ejecuta Rust por completo en tu iPad — sin nube, sin cuenta.