Publicado por
IronCalc: Motor de Hojas de Cálculo Moderno en Rust
Motor de spreadsheet de alto rendimiento con soporte para XLSX, WASM y múltiples lenguajes de programación
Vídeo tutorial en YouTube
Mira el vídeo completo sobre cómo instalar y usar IronCalc: Motor de Hojas de Cálculo Moderno en Rust en el canal GENBYTE:
¿Qué es IronCalc: Motor de Hojas de Cálculo Moderno en Rust?
IronCalc es un motor de hojas de cálculo moderno, en desarrollo activo, programado en Rust. Proporciona el núcleo del ecosistema IronCalc e incluye lector y escritor de archivos XLSX. Diseñado para ser utilizado desde diversos lenguajes como Python, JavaScript (WebAssembly), Node.js y potencialmente R, Julia o Go. El proyecto permite construir diferentes interfaces: terminal, aplicación de escritorio o integración en aplicaciones web propias. Se distribuye bajo licencias MIT y Apache-2.0 a elección del usuario.
Características principales
Motor de cálculo en Rust
Núcleo de alto rendimiento programado en Rust que evalúa fórmulas y gestiona modelos de hojas de cálculo con soporte para múltiples hojas y referencias cruzadas.
Lector y escritor XLSX nativo
Capacidad para leer y escribir archivos Excel (.xlsx) sin dependencias externas, incluyendo conversión a formato interno .ic para carga rápida.
Bindings WebAssembly
Compilación a WASM mediante wasm-pack para uso directo en navegadores y entornos JavaScript/TypeScript, permitiendo ejecución del motor en el cliente.
Soporte multi-lenguaje
API accesible desde Python, JavaScript (WASM), Node.js y con planes para R, Julia y Go a través de bindings nativos.
Arquitectura multi-frontend
Diseñado para servir como backend de diferentes skins: aplicación web (React), interfaz de terminal, aplicación de escritorio (Tauri/Electron) o integración en SaaS propio.
Despliegue con Docker y Caddy
Incluye Dockerfile multi-etapa y docker-compose con servidor Rust (Rocket) en puerto 8000 y proxy inverso Caddy sirviendo frontend en puerto 2080.
Licencia dual permisiva
Disponible bajo licencia MIT o Apache-2.0 a elección, facilitando integración en proyectos propietarios y open source.
Requisitos del sistema
- Docker y Docker Compose para despliegue en contenedores
- Rust toolchain (stable) para compilación nativa
- Node.js 24 y pnpm 9.15.4 para construcción del frontend y bindings WASM
- Herramientas de sistema: bash, curl, ca-certificates, make
- Objetivo wasm32-unknown-unknown para compilación WebAssembly
Instalación con Docker Compose
Despliegue con Docker Compose
Clonar el repositorio y levantar los servicios definidos en docker-compose.yml. Esto construye la imagen del servidor Rust (ironcalc-server) y el proxy Caddy (ironcalc-caddy), exponiendo la aplicación en el puerto 2080.
cd IronCalc
docker compose up –build
Compilación nativa del motor
Compilar el motor y herramientas de línea de comandos directamente con Cargo en modo release. Requiere toolchain Rust instalado.
Construcción completa (frontend + WASM + servidor)
El Dockerfile documenta la construcción completa: dependencias de sistema, toolchain WASM, Node.js vía nvm, compilación del servidor Rocket, bindings WASM, widget React y frontend de la aplicación web. Para desarrollo local sin Docker, replicar estos pasos manualmente.
rustup target add wasm32-unknown-unknown
cargo install wasm-pack
# Instalar Node.js 24 y pnpm 9.15.4
# Compilar servidor
cargo build –release –manifest-path webapp/app.ironcalc.com/server/Cargo.toml
# Compilar WASM
make -C bindings/wasm
# Compilar widget y frontend
cd webapp/IronCalc && npm install && npm run build
cd ../app.ironcalc.com/frontend && npm install && npm run build
Acceder al proyecto
Aplicación web (Docker Compose)
Tras ejecutar docker compose up –build, la interfaz web está disponible en http://localhost:2080. Caddy sirve el frontend estático y hace proxy inverso al servidor Rust en /api.
Servidor API directo
El servidor Rocket expone su API en el puerto 8000 dentro del contenedor (variable ROCKET_PORT=8000). En despliegue Docker Compose, Caddy enruta el tráfico de /api hacia este puerto.
Vista previa online
Versión de prueba temprana ejecutándose completamente en el navegador: https://app.ironcalc.com
Casos de uso
- Integración de motor de spreadsheet en aplicaciones SaaS propias con licencia permisiva
- Desarrollo de aplicaciones web de hojas de cálculo con backend Rust y frontend React
- Procesamiento y conversión automatizada de archivos XLSX en pipelines de datos
- Ejecución de cálculos de spreadsheet en el navegador vía WebAssembly sin servidor
- Creación de herramientas de línea de comandos para manipulación de hojas de cálculo
- Investigación y desarrollo de algoritmos de evaluación de fórmulas en Rust
Configuración avanzada
Uso del motor como biblioteca Rust
Añadir ironcalc como dependencia en Cargo.toml desde el repositorio Git y utilizar el modelo para crear hojas, establecer valores, evaluar fórmulas y exportar a XLSX. El ejemplo oficial muestra creación de modelo, población de celdas, adición de hoja con fórmula SUM y guardado a disco.
ironcalc = { git = "https://github.com/ironcalc/IronCalc", version = "0.8"}
// Ejemplo de uso en main.rs
use ironcalc::{
base::{expressions::utils::number_to_column, Model},
export::save_to_xlsx,
};
fn main() -> Result<(), Box<dyn std::error::Error>> {
let mut model = Model::new_empty("hello-calc.xlsx", "en", "UTC", "en")?;
for row in 1..100 {
for column in 1..100 {
let value = row * column;
model.set_user_input(0, row, column, format!("{}", value));
}
}
model.add_sheet("Calculation")?;
let last_column = number_to_column(100).unwrap();
let formula = format!("=SUM(Sheet1!A1:{}100)", last_column);
model.set_user_input(1, 1, 1, formula);
model.evaluate();
save_to_xlsx(&model, "hello-calc.xlsx")?;
Ok(())
}
Generación de documentación local
Generar la documentación de la API con cargo doc y servirla localmente para consulta offline.
cd target/doc
python -m http.server
# Visitar http://0.0.0.0:8000/ironcalc/
Conversión de plantillas XLSX a formato interno .ic
El binario xlsx_2_icalc (compilado en el Dockerfile) convierte archivos XLSX de prueba y plantillas al formato binario .ic para carga rápida en el frontend. El proceso se ejecuta automáticamente durante la construcción de la imagen Docker.
cargo build –manifest-path xlsx/Cargo.toml
# Convertir archivos
./target/debug/xlsx_2_icalc archivo.xlsx salida.ic
Gestión y mantenimiento
Ejecución de pruebas completas
El Makefile incluye objetivo 'tests' que ejecuta pruebas unitarias, de integración, linter (clippy) y formateo (rustfmt). Requiere toolchain Rust completo.
Cobertura de código
Generar informe de cobertura con 'make coverage' y servir el reporte HTML localmente para análisis.
cd target/coverage/html
python -m http.server
Actualización de dependencias
Las dependencias Rust se gestionan vía Cargo.lock/Cargo.toml. Las dependencias Node.js (frontend, widget) usan package.json y pnpm-lock.yaml en sus respectivos directorios. Actualizar con cargo update y pnpm update según corresponda.
Limpieza de artefactos de construcción
Eliminar directorios target/, dist/, node_modules/ y cachés de Docker para reconstrucción limpia.
rm -rf dist
rm -rf webapp/IronCalc/node_modules
rm -rf webapp/app.ironcalc.com/frontend/node_modules
docker system prune -f
Stack técnico
- Rust (motor principal, servidor Rocket, CLI)
- WebAssembly (wasm32-unknown-unknown, wasm-pack)
- React (frontend webapp, widget)
- TypeScript/JavaScript (bindings WASM, tooling)
- Node.js 24 / pnpm 9.15.4 (build frontend)
- Docker (multi-stage build, runtime)
- Docker Compose (orquestación server + caddy)
- Caddy (proxy inverso, servidor estático, TLS automático)
- Debian bookworm-slim (imagen base runtime servidor)
- SQLite (base de datos embebida del servidor)
- Make (automatización de tareas: test, coverage, docs)
Referencias oficiales
- Repositorio oficial GitHub: https://github.com/ironcalc/IronCalc
- Sitio web del proyecto: https://www.ironcalc.com
- Documentación de la API (docs.rs): https://docs.rs/ironcalc/latest/ironcalc/
- Vista previa en navegador: https://app.ironcalc.com
- Comunidad Discord: https://discord.gg/zZYWfh3RHJ
- Licencia MIT: https://github.com/ironcalc/IronCalc/blob/main/LICENSE-MIT
- Licencia Apache-2.0: https://github.com/ironcalc/IronCalc/blob/main/LICENSE-Apache-2.0
- Cobertura de código (Codecov): https://codecov.io/gh/ironcalc/IronCalc
Apoya el canal GENBYTE
¿Te ha sido útil este contenido?
Suscríbete a YouTube
Newsletter GENBYTE
Ko-fi
Contacto: [email protected]