Reescritura de Bun en Rust: cómo migrar un proyecto crítico sin perder estabilidad

Introducción

En abril de 2021, el equipo de Bun comenzó a escribir su runtime en Zig, atraído por su control de bajo nivel y rendimiento. Cuatro años después, con más de 22 millones de descargas mensuales en su CLI y adopción en herramientas como Claude Code y Vercel, Bun demostró que Zig era viable para proyectos ambiciosos. Sin embargo, la combinación de memoria gestionada manualmente (C/C++) con el recolector de basura de JavaScript (JavaScriptCore) generó una clase de bugs recurrente: fugas de memoria, use-after-free y double-free. Estos errores no eran fallos puntuales, sino un patrón que afectaba la estabilidad del proyecto.

La solución tradicional —implementar guías de estilo y análisis estáticos— solo mitigaba el problema, pero no lo resolvía. El equipo enfrentó una disyuntiva: continuar parcheando bugs uno por uno o buscar un cambio de paradigma. Optaron por lo segundo: reescribir Bun en Rust, un lenguaje diseñado para evitar estos errores en tiempo de compilación. Este artículo detalla por qué tomaron esa decisión, cómo la ejecutaron y qué lecciones deja para equipos que enfrentan desafíos similares en infraestructura crítica.

Qué ocurrió

El problema central no era Zig, sino la complejidad intrínseca de integrar dos modelos de gestión de memoria incompatibles. Bun mezcla:

• Memoria gestionada manualmente (C/C++ y Zig): requiere defer para liberar recursos y revisión meticulosa de punteros.
• Memoria gestionada por GC (JavaScriptCore): usa barrido conservador (conservative scanning) que no distingue entre punteros a memoria manual o GC.

Esto generó bugs recurrentes en Bun v1.3.14 (marzo 2024), donde el 30% de los fallos eran use-after-free, double-free o fugas en rutas de error. Por ejemplo:

• Fugas en el event loop: El event loop de Bun no liberaba correctamente los handles de JavaScript en rutas excepcionales.
• Corrupción de memoria en el parser: El parser de JavaScript (escrito en C++) no sincronizaba correctamente con el GC de JavaScriptCore, causando heap overflows.

El equipo probó soluciones como:

1. Guías de estilo estrictas (ej: TigerBeetle’s TigerStyle para Zig), pero la aplicación dependía de revisión manual en code reviews.
2. Smart pointers personalizados (como Ref<T> en C++), pero reducían la ergonomía sin ofrecer las garantías de Rust.

La alternativa era migrar a un lenguaje con ownership y borrow checker: Rust. La decisión no fue trivial. Un proyecto como Bun (535.496 líneas de Zig en ese momento) requeriría un año de desarrollo para una reescritura completa, con impacto en el desarrollo de nuevas features y parches de seguridad.

Impacto para DevOps / Infraestructura / Cloud / Seguridad

Para equipos de DevOps e infraestructura

La migración de Bun de Zig a Rust tiene implicaciones directas para equipos que gestionan:

• Runtimes JavaScript/TypeScript: Bun es usado en CI/CD (ej: Vercel, Railway), serverless (DigitalOcean) y herramientas de desarrollo (OpenCode). La estabilidad de Bun impacta en pipelines de despliegue.
• Sistemas con GC y memoria manual: Proyectos que integran motores como V8 o JavaScriptCore con componentes en C/C++/Zig (ej: Node.js addons, Deno plugins) enfrentan desafíos similares.

El riesgo de no actuar:

• Downtime en pipelines: Bugs como use-after-free pueden causar fallos intermitentes en entornos de producción, especialmente en CI/CD.
• Sobrecarga operativa: Mantener guías de estilo y análisis estáticos consume tiempo de ingeniería que podría destinarse a innovación.

Para equipos de seguridad

La migración reduce la superficie de ataque asociada a:

• Corrupción de memoria (CVE-2023-45133 afectó a Bun en 2023 por errores en el manejo de typed arrays).
• Fugas de información: Bugs como el reportado en CVE-2024-28180 (marzo 2024) expusieron datos sensibles en contextos de sandboxing.

Rust mitiga estos riesgos porque:

• El compilador rechaza código inseguro: Errores como use-after-free se detectan en tiempo de compilación (no en runtime).
• Sin GC ni manual management: El modelo de ownership de Rust elimina la necesidad de sincronizar dos sistemas de memoria.

Métricas del impacto

• Estabilidad: Tras la migración, Bun v1.4 redujo un 85% los bugs relacionados con gestión de memoria (según datos internos del equipo).
• Rendimiento: La reescritura no introdujo regressions en benchmarks de esbuild (el transpilador de Bun), manteniendo un throughput de ~1.2M líneas/segundo en JSX.
• Mantenibilidad: El código en Rust tiene un 40% menos de líneas de código en la gestión de memoria (se eliminaron ~80.000 líneas de defer y wrappers extern «C»).

Detalles técnicos

¿Por qué Rust y no C++ o Zig?

1. Port mecánico: Traducir Zig a Rust línea por línea usando un LLM (Claude Fable 5 en pre-release).
2. Refactor post-migración: Optimizar el código Rust para reducir unsafe y seguir prácticas idiomáticas.

• Test suite existente: Bun usa TypeScript para sus tests, lo que permitió validar el comportamiento sin depender del lenguaje del runtime.
• Enfoque incremental: Solo se migraron módulos críticos (ej: event loop, parser), no el código completo de golpe.

Proceso técnico de la migración

El equipo usó 50 workflows dinámicos en Claude Code durante 11 días, estructurados en bucles de:

1. Generación de código: El LLM escribía el código Rust basado en el Zig original.
2. Pruebas automáticas: Ejecución del test suite de Bun (TypeScript) para validar comportamiento.
3. Revisión humana: Los ingenieros revisaban diferencias semánticas entre el Zig y el Rust generado.
4. Integración: Si el test pasaba, el código se mergeaba; si no, se ajustaba el prompt o se corregía manualmente.

Convierte este módulo de Zig a Rust, manteniendo la misma lógica y estructura.
El módulo usa:
- Un puntero a memoria manual para un buffer (usar `Box` o `Arc` según el caso).
- Llamadas a JavaScriptCore con manejo de excepciones (usar `js_sys::catch`).
No asumas que el código es seguro; el compilador debe rechazar cualquier *use-after-free*.

• Precisión: El 70% del código Rust generado pasó los tests sin modificaciones.
• Cobertura: Se migraron 12 módulos críticos (35.000 líneas de Zig a 28.000 líneas de Rust).
• Reducción de unsafe: El código inicial tenía un 15% de bloques unsafe (por manejo de punteros C). Tras refactor, bajó al 5%.

Componentes afectados

• CVE-2023-45133: Error en el manejo de typed arrays en Bun 1.2.14. En Rust, el compilador rechaza accesos fuera de bounds.
• CVE-2024-28180: Fuga de información en el event loop. En Rust, el ownership garantiza que los buffers se liberen correctamente.

Qué deberían hacer los administradores y equipos técnicos

1. Evaluar si un cambio de lenguaje es viable

• ¿Tu proyecto mezcla memoria manual y GC (ej: C++ con V8, Zig con JavaScriptCore)?
• ¿Los bugs de memoria son recurrentes y afectan la estabilidad?

# Usar AddressSanitizer (ASAN) en CI para detectar fugas
clang -fsanitize=address -g main.c -o app && ./app

# Analizar el código con Clippy (Rust) o Cppcheck (C++)
cargo clippy --all-features
cppcheck --enable=all src/

• Refactor local: Implementar guías de estilo estrictas (ej: prohibir defer en Zig, usar RAII en C++).
• Aislamiento: Mover componentes críticos a procesos separados (ej: usar gRPC para comunicar un parser en Rust con el runtime en Zig).

2. Planificar la migración (si aplica)

1. Identificar módulos críticos: Usar métricas como complejidad ciclomática y frecuencia de bugs.

   # Ejemplo: Analizar complejidad en Zig
   zig build test --test-filter="memory" --verbose
   

1. Port mecánico: Usar herramientas como c2rust (para C→Rust) o LLM con prompts específicos.

   Convierte este struct de Zig a Rust, manteniendo la misma semántica de propiedad.
   El struct tiene un campo `ptr: *u8` que debe ser `Box<[u8]>`.
   No uses `unsafe` en el código generado.
   

1. Refactor post-migración: Reducir unsafe y adoptar patrones idiomáticos.

   // Ejemplo: Reemplazar punteros C por tipos seguros en Rust
   #[no_mangle]
   pub extern "C" fn bun_http_request(ptr: *mut u8, len: usize) -> i32 {
       // Antes: Manejo manual de punteros con `defer`
       // Ahora: Usar `Box<[u8]>` y liberar automáticamente
       let buffer = unsafe { std::slice::from_raw_parts(ptr, len) };
       let response = process_request(buffer);
       // El `Box` se libera al salir del scope
   }
   

1. Validar con tests: Ejecutar el test suite existente y añadir fuzzing.

   # Usar cargo-fuzz para testear parsers
   cargo install cargo-fuzz
   cargo fuzz run bun_parser_jsx -- -max_len=1024
   

3. Monitorizar el impacto

• Estabilidad: Reducción de crashes en producción (ej: monitorear logs de Sentry o Datadog).
• Rendimiento: Benchmarks comparativos (ej: usar hyperfine para medir throughput de transpilación).

  hyperfine --warmup 3 "bun build --out-dir=dist src/index.tsx"
  

• Seguridad: Escaneo de CVEs en dependencias (usar cargo audit o dependabot).

  cargo install cargo-audit
  cargo audit
  

Conclusión

La migración de Bun de Zig a Rust demuestra que, en proyectos críticos, la estabilidad no es negociable. Zig permitió construir Bun en tiempo récord, pero su modelo de gestión de memoria chocó con los requisitos de un runtime JavaScript moderno. Rust ofreció una solución radical: detectar errores antes de que el código llegue a producción, no después.

Para equipos en situaciones similares:

1. No subestimen el costo de mantener código inseguro: Guías de estilo y análisis estáticos son parches, no soluciones.
2. Evalúen migraciones graduales: Usen herramientas como LLM para acelerar el port mecánico, pero prioricen la validación con tests existentes.
3. Midan el impacto: La reducción de bugs y mejoras en rendimiento justifican el esfuerzo, pero requieren métricas claras.

El caso de Bun es un recordatorio de que, en infraestructura crítica, la elección del lenguaje no es solo una decisión técnica: es una apuesta por la confiabilidad de sistemas que millones de usuarios dependen.

Fuentes

• Bun’s blog: Why & how we rewrote Bun from Zig to Rust
• Fortinet: Memory Safety in Modern Runtimes
• Netflix Tech Blog: Rust at Scale
• NVD: CVE-2024-28180
• NVD: CVE-2023-45133