Volver al blog
BunWebAssemblyVideojuegosWebSocket

NFSU2 en el navegador: qué tiene que ver Bun con esto

09 de noviembre de 2026·7 min de lectura·Diego Horvatti

Alguien puso Need for Speed Underground 2 a correr en una pestaña del navegador, con modo online. El proyecto está en nfsu2.xyz y se hizo viral entre devs por la razón de siempre: un juego de 2004, que pedía CD y tarjeta de video dedicada, ahora se abre con un link. Ver NFSU2 en el navegador despierta la nostalgia de mucha gente. A mí también me deja una pregunta técnica más interesante: ¿qué tiene que existir del lado del servidor para que esto funcione sin caerse?

Aviso antes que nada: no voy a afirmar cuál es el stack exacto del proyecto, porque no está documentado de forma clara. Voy a usar el caso como gancho y mostrar cómo armaría yo la parte de backend con Bun. Ahí es donde el tema toca el día a día de quien escribe TypeScript.

¿Cómo corre un juego de 2004 en el navegador?

En la práctica, hay tres caminos para llevar un juego viejo a la web:

  • Emulación o capa de compatibilidad compilada a WebAssembly. El binario original corre dentro de algo que finge ser un Windows XP con DirectX.
  • Port del código, cuando el código fuente existe (oficial o por ingeniería inversa) y se recompila con Emscripten a WASM + WebGL.
  • Reimplementación del motor, que lee los archivos originales del juego y dibuja todo con código nuevo.

Sea cual sea el camino, el navegador hace el trabajo pesado. WebAssembly corre la lógica cerca de la velocidad nativa, WebGL o WebGPU dibuja los autos y la Gamepad API lee tu control. Todo esto ya está maduro desde hace algunos años. Lo que cambió fue el valor de hacerlo con juegos de verdad, de varios gigas, y no solo con demos.

El cuello de botella rara vez es la CPU del cliente. Es la red. Un NFSU2 tiene cientos de megas de texturas, modelos y audio. Si mandas todo de una vez, el jugador se rinde en la pantalla de carga. Me acuerdo de esperar la barrita del CD en 2004. Nadie tiene esa paciencia en 2026.

Dónde entra Bun en esta historia

Un proyecto así tiene dos servicios en el backend, aunque sean pequeños:

  1. Un servidor de assets estáticos grandes, con caché agresiva.
  2. Un servidor de tiempo real para el multijugador: lobby, posición de los autos, chat.

Bun resuelve los dos con su API nativa, sin framework y sin dependencias. Para servir assets, Bun.file devuelve un archivo perezoso, que solo se lee del disco cuando se envía la respuesta:

Bun.serve({
  port: 3000,
  async fetch(req) {
    const path = new URL(req.url).pathname
    if (path.includes('..')) return new Response('nope', { status: 400 })

    const file = Bun.file(`./assets${path}`)
    if (!(await file.exists())) return new Response('404', { status: 404 })

    return new Response(file, {
      headers: { 'Cache-Control': 'public, max-age=31536000, immutable' },
    })
  },
})

Ese immutable solo es seguro si el nombre del archivo tiene hash (carros.a1b2c3.pak). Si cambia el archivo, cambia el nombre. Así el navegador nunca descarga dos veces el mismo paquete de 80 MB. Y en la vida real pondría una CDN adelante, porque servir gigas directo desde tu proceso es pagar caro por ancho de banda.

Multijugador con el WebSocket nativo de Bun

La parte que más me interesa es el online. Bun trae WebSocket integrado en Bun.serve, con pub/sub nativo. Es exactamente el modelo de un lobby de carreras: cada sala es un tópico, cada auto publica su posición y todos en la sala la reciben.

type Data = { room: string; player: string }

Bun.serve<Data>({
  port: 4000,
  fetch(req, server) {
    const url = new URL(req.url)
    const room = url.searchParams.get('room') ?? 'lobby'
    const player = crypto.randomUUID()
    if (server.upgrade(req, { data: { room, player } })) return
    return new Response('use WebSocket', { status: 426 })
  },
  websocket: {
    open(ws) {
      ws.subscribe(ws.data.room)
    },
    message(ws, msg) {
      // reenvía posición/velocidad a los demás de la sala
      ws.publish(ws.data.room, msg)
    },
    close(ws) {
      ws.unsubscribe(ws.data.room)
    },
  },
})

Son unas 25 líneas. En Node llegarías al mismo lugar con ws o Socket.IO, y funciona bien. La diferencia es que en Bun esto ya viene listo, y el publish se hace del lado nativo. No tienes que recorrer una lista de clientes en JavaScript con cada mensaje. Con 8 autos en una sala mandando 20 actualizaciones por segundo, son 160 mensajes por segundo entrando y más de mil saliendo. Multiplícalo por cien salas y entiendes por qué ese detalle importa.

En un juego online, el servidor no necesita ser listo. Necesita ser rápido y no confiar en nadie.

Qué cambia en tu código cuando el cliente es un juego

Esta es la parte que sorprende a quien viene del CRUD. Algunas lecciones que sirven para cualquier app en tiempo real, no solo para carreras:

Manda binario, no JSON. Una posición es x, y, z, rotación y velocidad. En JSON eso son unos 80 bytes de texto. En un Float32Array son 28 bytes. A 20 Hz por jugador, la diferencia se nota en la factura de ancho de banda y en el lag.

// cliente: 7 floats = 28 bytes
const buf = new Float32Array([x, y, z, rx, ry, rz, speed])
socket.send(buf)

Valida en el servidor. El cliente es un navegador. O sea, cualquiera abre las DevTools y manda lo que quiera. Si el servidor solo reenvía, alguien va a teletransportar su auto a la meta el primer día. Lo mínimo es revisar el tamaño del mensaje y rechazar saltos de posición imposibles. Es aburrido, pero es la regla de siempre: nunca confíes en el input.

Limita la tasa. Un cliente con bugs mandando 1000 mensajes por segundo tumba la sala entera. Un contador por conexión, reiniciado cada segundo, ya resuelve el 90% de los casos.

Piensa en la reconexión desde el principio. El Wi-Fi se cae. La pestaña pasa a segundo plano y el navegador estrangula los timers. El jugador vuelve y espera estar en la misma carrera. Eso significa guardar el estado de la sala en algún lugar que no sea solo la memoria de la conexión.

¿Se puede? La parte legal que nadie quiere leer

Voy a ser honesto. Need for Speed es una marca de Electronic Arts. Los autos, las canciones de la banda sonora (sí, esa de Snoop Dogg con The Doors) y los gráficos tienen dueño. Los proyectos de preservación de juegos viven en una zona gris. Y la historia muestra que muchos terminan con una solicitud de retiro, por muy bien hechos que estén.

Eso no le quita mérito técnico. Pero si estás pensando en hacer algo parecido, separa las cosas. El motor, el netcode y el servidor son tuyos y pueden ir a tu portafolio. Los assets de un juego comercial no lo son, y distribuirlos públicamente es buscarse problemas. La versión más segura del mismo aprendizaje es hacer tu propio jueguito de carreras, con modelos libres, y usar exactamente la misma arquitectura.

¿Vale la pena usar Bun para un proyecto así?

Mi opinión: para este tipo de backend, sí, y sin pensarlo mucho. Servidor de archivos más WebSocket con pub/sub es el caso de uso donde Bun está más redondo. Escribes TypeScript directo, sin build, sin ws, sin Express, y el servidor arranca en milisegundos. Para un proyecto personal, eso ya es la mitad de la motivación resuelta.

Donde tendría cuidado: si el juego crece a miles de salas, el cuello de botella dejará de ser el runtime. Pasará a ser el estado compartido entre varias instancias, porque el publish de Bun solo llega a quien está conectado al mismo proceso. Ahí entran Redis, NATS o algo similar para distribuir los mensajes. Ningún runtime resuelve eso por ti.

NFSU2 corriendo en una pestaña me recordó algo: la web se volvió una plataforma de juegos seria, y el backend que la sostiene cabe en un archivo de TypeScript. Me gusta mucho esa combinación de herramienta simple con problema difícil. Si quieres ver lo que ando construyendo en esta línea, échale un vistazo a mis proyectos.

Resumen para LinkedIn

Alguien puso Need for Speed Underground 2 a correr en una pestaña del navegador. Con modo online.

Un juego de 2004 que pedía CD y tarjeta de video dedicada ahora se abre con un link. WebAssembly y WebGL ya se encargan del trabajo pesado.

Para mí, la pregunta más interesante es qué sostiene el multijugador del lado del servidor sin caerse.

Con Bun, unas 25 líneas de TypeScript resuelven el lobby: WebSocket nativo, una sala por tópico y el publish corriendo del lado nativo.

El resto es la disciplina de siempre: mandar binario en vez de JSON, validar todo en el servidor, limitar la tasa y pensar en la reconexión desde el primer día.

Escribí en el blog cómo armaría yo ese backend y dónde empieza a quedarse corto. Si te gustan las herramientas simples resolviendo problemas difíciles, vale la pena leerlo.

#Bun #TypeScript #WebSocket #WebAssembly #DesarrolloDeVideojuegos