En el video de ¿Rust habría evitado los hackeos de octubre? varios dejaron la misma pregunta en los comentarios, más o menos así:
"Si Rust es más seguro y más rápido, ¿por qué sigues recomendando JavaScript y Python en vez de Go o Rust?"
Es una pregunta justa, y la respuesta corta es que mezcla dos problemas distintos. Separarlos explica por qué Bun acaba de hacer algo que cambia la conversación.
Todos los lenguajes llegan al mismo lugar
Antes de entrar en detalle, una idea que ordena todo lo demás: no existe un lenguaje que el procesador entienda, salvo el código máquina. Rust, Go, C++, JavaScript, Python: todos terminan convertidos en las mismas instrucciones binarias. La diferencia entre un lenguaje "rápido" y uno "lento" no está en el destino, sino en qué viaja junto con tu código para llegar ahí y mantenerlo funcionando.
Piénsalo como una fila de lenguajes que apuntan al mismo lugar:
- C, C++, Rust → código máquina. Casi nada en medio. El compilador decide todo antes de ejecutar y el binario corre solo.
- Go, Java, C# → código máquina + un garbage collector que viaja dentro del binario, liberando memoria mientras tu programa corre.
- JavaScript, Python, Ruby → código máquina + garbage collector + un intérprete + un compilador JIT que traduce en caliente, mientras el programa ya está corriendo.
Cada pieza que acompaña a tu código es una ayuda que te quita trabajo: el garbage collector te libra de liberar memoria a mano, el intérprete te libra de compilar. Pero cada ayuda cuesta memoria y CPU en tiempo de ejecución. Por eso JavaScript consume más que Go, y Go más que Rust: no porque el lenguaje sea peor, sino porque lleva más compañía.
Y aquí es donde el comentario mezcla dos cosas. Rust gana en dos frentes distintos, y solo uno de ellos tiene que ver con esa fila.
Dos problemas que no son el mismo
El video de octubre hablaba de seguridad de memoria: use-after-free, buffer overflows, lo que pasa cuando C y C++ te dejan tocar memoria que ya no es tuya. Rust resuelve eso con el borrow checker. Pero JavaScript, Python, Go y Java ya eran seguros en memoria desde siempre, porque tienen garbage collector: nadie libera memoria a mano, así que nadie la libera dos veces.
Lo que el comentario señala en realidad es otra cosa: rendimiento. ¿Por qué JavaScript es más lento y consume más memoria que Go o Rust? Y ahí la respuesta no está en el lenguaje, sino en lo que lo acompaña: el intérprete y el JIT.
Cómo corre JavaScript hoy: JIT
Cuando ejecutas TypeScript con Node o con Bun, pasa esto: TypeScript se transpila a JavaScript y los tipos se borran. Luego el motor (V8 en Node, JavaScriptCore en Bun) empieza interpretando el código línea por línea. A medida que detecta funciones que se llaman mucho, las compila a código máquina mientras el programa corre. Eso es el JIT, just-in-time: compilar justo a tiempo.
Funciona, pero paga tres costos:
- Arranque lento. Empieza interpretando; el código rápido llega después de calentar.
- Hilos compilando al lado de tu app. El JIT corre dos o tres hilos que compilan, descartan y recompilan código mientras tu programa trabaja. Eso es memoria y CPU que no son tuyos.
- Chequeos de tipo por todos lados. Como no sabe los tipos de antemano, cada operación pregunta "¿esto sigue siendo un número?". Si adivinó mal, tira el código optimizado y vuelve a empezar.
Qué cambia con Bun AOT
Jarred Sumner, el creador de Bun, lleva semanas publicando sobre Bun AOT (ahead-of-time): compilar TypeScript a código máquina antes de ejecutar, con un solo comando:
bun build --compile --aot app.ts
Bun parsea tu TypeScript, usa los tipos, genera una representación intermedia tipada, optimiza, y usa B3 (el mismo compilador que usan los JITs de JavaScriptCore) para emitir código máquina ARM64 o x64. El resultado es un binario. Cuando lo ejecutas, no hay intérprete, no hay calentamiento, no hay hilos compilando. Solo corre.
En la fila de antes, JavaScript se mueve un puesto: pierde al intérprete y al JIT, y se queda solo con el garbage collector. Es decir, pasa a la fila de Go.
Los números que mostró:
- Claude Code CLI compilado con AOT: arranque 24% más rápido, 48% menos memoria, 46% menos CPU. Mismo código.
- El compilador de TypeScript 6 (370,000 líneas, sin tocar una) compilado con AOT: 3.3 veces más rápido, 2.7 veces menos memoria.
- Con
--trim, que borra las partes de Bun que no usas, un servidor HTTP pasó de 89 MB a 25 MB.
Y la frase que resume su apuesta:
"En vez de que reescribas en Rust, reescribimos el compilador de JavaScript para que emita código nativo."
Está mergeado desde el 29 de octubre, todavía en pruebas antes de la release.
Por qué tus tipos ahora importan
Aquí está lo interesante. Los tipos de TypeScript siempre fueron una ficción de compilación: se borraban y en runtime todo era dinámico. Con AOT, por primera vez esos tipos llegan al compilador que genera código máquina.
Cuando el compilador puede probar que una variable siempre es number, emite una instrucción directa, sin chequeos. Cuando no puede, porque hay un any, un cast con as o un JSON.parse, deja un chequeo en runtime y un camino lento. Ese camino lento es básicamente JavaScript dinámico compilado.
La consecuencia: un proyecto con strict activado y sin any sale más rápido que uno lleno de agujeros de tipo. El tipado estricto deja de ser documentación y pasa a ser optimización. Como en Go.
Se parece a Go, no a Rust
Con AOT, TypeScript se acerca mucho a Go. Pero no a Rust, ni con tipado perfecto. Tres razones:
- Sigue habiendo garbage collector. El recolector de JavaScriptCore viaja dentro del binario y sigue pausando, escaneando y liberando objetos en ejecución. Rust libera memoria en puntos que el compilador conoce de antemano; nadie corre al lado.
- El modelo de datos. En Rust un struct de tres enteros son 12 bytes contiguos. En JavaScript cada objeto es una asignación en el heap con cabecera, y un array de objetos es un array de punteros a cosas dispersas por la memoria. Eso castiga la caché del procesador.
- Precisión numérica.
numbersiempre es un double de 64 bits. No hayi32,u8nif32. El propio Jarred reconoce que falta soportar tipos con tamaño.
¿Y los typed arrays? Int32Array existe desde ES2015, pero es memoria tipada, no variables tipadas: al leer arr[0] sale un number normal. ¿Y la propuesta de TC39 para anotaciones de tipo en JavaScript? Ordena al motor ignorarlas; su meta es correr TypeScript sin transpilar, no optimizar. Y cada vez que alguien intentó añadir tipos con tamaño que cambien la semántica (AssemblyScript, asm.js, Static TypeScript), terminó con otro lenguaje que ya no corre npm.
El propio Jarred lo dijo después del lanzamiento: para que TypeScript y JavaScript alcancen el rendimiento de C o Rust, y no solo el de Go, haría falta una sintaxis nueva. AOT está diseñado para correr código existente sin cambios; lo que venga después tendría que proponerse sin romper nada.
La diferencia con Rust ya no está en cómo se compila, sino en lo que el lenguaje promete.
Entonces, ¿reescribo mi backend en Rust?
Volviendo al comentario. Cinco razones para no hacerlo, aunque la IA te escriba el código:
- El costo de reescribir casi nunca se recupera. Tu backend tiene años de bugs corregidos y lógica que nadie recuerda por qué existe. La IA traduce código rápido; el conocimiento tácito no se traduce.
- El cuello de botella rara vez es el lenguaje. Si tu endpoint tarda 80 ms y 75 son Postgres, Rust te ahorra algo de los otros 5.
- El ecosistema, en la era de la IA. Ya no es que no puedas escribir un SDK: la IA te lo genera en minutos. El problema es que ahora ese código es tuyo. Cuando el servicio cambia la API, el SDK oficial lo actualiza el proveedor; el tuyo lo arreglas tú. Y la IA depura mejor lo que conoce: un SDK con años en npm tiene miles de issues y posts en su entrenamiento; el tuyo no lo conoce nadie, ni la IA.
- El equipo. Rust tiene curva real; el borrow checker frustra a quien viene de lenguajes con garbage collector.
- Bun AOT te da gran parte de la ganancia sin tocar una línea.
Y tres casos donde Rust sí tiene sentido:
- El CPU es el cuello de botella real: parsers, compiladores, decodificadores, criptografía.
- Latencia predecible sin pausas de GC: trading, audio, juegos, tiempo real.
- La memoria es el costo dominante a escala masiva.
El mejor ejemplo lo dio Anthropic esta misma semana: migraron un servicio crítico de Python a Rust con Fable 5.2, y ahora arranca 26 veces más rápido. Un servicio. No todo el backend.
Cierre
Durante años el techo de JavaScript fue el JIT: el lenguaje permitía mucho más de lo que el motor entregaba. Bun AOT quita ese techo y deja a TypeScript al nivel de Go con el mismo código.
Lo que queda por encima ya es el lenguaje. Para llegar a Rust haría falta sintaxis nueva, y el día que TypeScript tenga enteros con tamaño, ownership y borrow checker, deja de correr npm. Y npm es toda su ventaja.
La pregunta ya no es "¿Rust o TypeScript?", sino "¿cuánta velocidad necesitas antes de que el tipado estricto deje de alcanzar?"