Voltar para o blog
BunWebAssemblyGamesWebSocket

NFSU2 no navegador: o que o Bun tem a ver com isso

09 de novembro de 2026·6 min de leitura·Diego Horvatti

Alguém colocou Need for Speed Underground 2 pra rodar numa aba do navegador, com modo online. O projeto está em nfsu2.xyz e viralizou entre devs pelo motivo de sempre: um jogo de 2004, que pedia CD e placa de vídeo dedicada, agora abre com um link. Ver o NFSU2 no navegador mexe com a nostalgia de muita gente. Pra mim também tem uma pergunta técnica mais interessante: o que precisa existir do lado do servidor pra isso funcionar sem cair?

Aviso antes de tudo: não vou cravar a stack exata do projeto, porque ela não está documentada de forma clara. Vou usar o caso como gancho e mostrar como eu montaria a parte de backend com Bun, que é onde o assunto encosta no dia a dia de quem escreve TypeScript.

Como um jogo de 2004 roda no navegador?

Na prática, existem três caminhos para trazer um jogo antigo pra web:

  • Emulação ou camada de compatibilidade compilada pra WebAssembly. O binário original roda dentro de algo que finge ser um Windows XP com DirectX.
  • Port do código, quando o código-fonte existe (oficial ou por engenharia reversa) e é recompilado com Emscripten pra WASM + WebGL.
  • Reimplementação da engine, que lê os arquivos originais do jogo e desenha tudo com código novo.

Qualquer que seja o caminho, o navegador faz o trabalho pesado: WebAssembly roda a lógica perto da velocidade nativa, WebGL ou WebGPU desenha os carros e a Gamepad API lê o seu controle. Isso já está maduro há alguns anos. O que mudou foi a coragem de fazer com jogos de verdade, de vários gigas, e não só com demos.

O gargalo raramente é a CPU do cliente. É a rede. Um NFSU2 tem centenas de megas de texturas, modelos e áudio. Se você manda tudo de uma vez, o jogador desiste na tela de loading. Lembro de esperar a barrinha do CD carregar em 2004. Ninguém tem essa paciência em 2026.

Onde o Bun entra nessa história

Um projeto desses tem dois serviços no backend, mesmo que pequenos:

  1. Um servidor de assets estáticos grandes, com cache agressivo.
  2. Um servidor de tempo real pro multiplayer: lobby, posição dos carros, chat.

O Bun resolve os dois com a API nativa, sem framework e sem dependência. Pra servir assets, Bun.file devolve um arquivo preguiçoso, que só é lido do disco quando a resposta é enviada:

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' },
    })
  },
})

Esse immutable só é seguro se o nome do arquivo tiver hash (carros.a1b2c3.pak). Mudou o arquivo, mudou o nome. Assim o navegador nunca baixa o mesmo pacote de 80 MB duas vezes. E na vida real eu colocaria uma CDN na frente, porque servir gigas direto do seu processo é pagar caro por banda.

Multiplayer com WebSocket nativo do Bun

A parte que mais me interessa é o online. O Bun tem WebSocket embutido no Bun.serve, com pub/sub nativo. Isso é exatamente o modelo de um lobby de corrida: cada sala é um tópico, cada carro publica a posição dele, todo mundo da sala recebe.

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) {
      // repassa posição/velocidade pros outros da sala
      ws.publish(ws.data.room, msg)
    },
    close(ws) {
      ws.unsubscribe(ws.data.room)
    },
  },
})

São umas 25 linhas. Em Node você chegaria no mesmo lugar com ws ou Socket.IO, e funciona bem. A diferença é que no Bun isso já vem pronto, e o publish é feito no lado nativo, sem você iterar uma lista de clientes em JavaScript a cada mensagem. Com 8 carros numa sala mandando 20 atualizações por segundo, são 160 mensagens por segundo entrando e mais de mil saindo. Multiplica por cem salas e você entende por que esse detalhe importa.

Num jogo online, o servidor não precisa ser esperto. Precisa ser rápido e não confiar em ninguém.

O que muda no seu código quando o cliente é um jogo

Aqui está a parte que pega quem vem de CRUD. Algumas lições que valem pra qualquer app em tempo real, não só pra corrida:

Mande binário, não JSON. Uma posição é x, y, z, rotação e velocidade. Em JSON isso vira uns 80 bytes de texto. Num Float32Array são 28 bytes. A 20 Hz por jogador, a diferença aparece na conta de banda e no lag.

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

Valide no servidor. O cliente é um navegador, ou seja, qualquer pessoa abre o DevTools e manda o que quiser. Se o servidor só repassa, alguém vai teleportar o carro pra linha de chegada no primeiro dia. O mínimo é checar o tamanho da mensagem e rejeitar saltos de posição impossíveis. É chato, mas é a mesma regra de sempre: nunca confie no input.

Limite a taxa. Um cliente bugado mandando 1000 mensagens por segundo derruba a sala inteira. Um contador por conexão, zerado a cada segundo, já resolve 90% dos casos.

Pense em reconexão desde o começo. Wi-Fi cai. Aba vai pra segundo plano e o navegador estrangula os timers. O jogador volta e espera estar na mesma corrida. Isso significa guardar o estado da sala em algum lugar que não seja só a memória da conexão.

Pode isso? A parte jurídica que ninguém quer ler

Vou ser honesto aqui. Need for Speed é uma marca da Electronic Arts. Os carros, as músicas da trilha (sim, aquela de Snoop Dogg com The Doors) e os gráficos têm donos. Projetos de preservação de jogos vivem numa área cinzenta, e a história mostra que muitos acabam com um pedido de remoção, por mais bem feitos que sejam.

Isso não diminui o mérito técnico. Mas se você está pensando em fazer algo parecido, separe as coisas: a engine, o netcode e o servidor são seus e podem virar portfólio. Os assets de um jogo comercial não são, e distribuir isso publicamente é pedir problema. A versão mais segura do mesmo aprendizado é fazer um joguinho de corrida próprio, com modelos livres, e usar exatamente a mesma arquitetura.

Vale usar Bun pra um projeto assim?

Minha opinião: pra esse tipo de backend, sim, e sem pensar muito. Servidor de arquivo mais WebSocket com pub/sub é o caso de uso em que o Bun está mais redondo. Você escreve TypeScript direto, sem build, sem ws, sem Express, e o servidor sobe em milissegundos. Pra um projeto paralelo, isso é metade da motivação resolvida.

Onde eu teria cuidado: se o jogo crescer pra milhares de salas, o gargalo vai deixar de ser o runtime. Vai ser estado compartilhado entre várias instâncias, porque o publish do Bun só alcança quem está conectado no mesmo processo. Aí entra Redis, NATS ou algo do tipo pra distribuir as mensagens. Nenhum runtime resolve isso por você.

O NFSU2 rodando numa aba me lembrou de uma coisa: a web virou uma plataforma de jogo séria, e o backend que sustenta isso cabe num arquivo de TypeScript. Eu gosto bastante dessa combinação de ferramenta simples com problema difícil. Se quiser ver o que eu ando construindo nessa linha, dá uma olhada nos meus projetos.

Resumo para o LinkedIn

Alguém colocou Need for Speed Underground 2 pra rodar numa aba do navegador. Com modo online.

Um jogo de 2004 que pedia CD e placa de vídeo dedicada agora abre com um link. WebAssembly e WebGL já dão conta do trabalho pesado.

Pra mim, a pergunta mais interessante é o que segura o multiplayer do lado do servidor sem cair.

Com Bun, umas 25 linhas de TypeScript resolvem o lobby: WebSocket nativo, uma sala por tópico e o publish rodando no lado nativo.

O resto é a disciplina de sempre: mandar binário em vez de JSON, validar tudo no servidor, limitar a taxa e pensar em reconexão desde o primeiro dia.

Escrevi no blog como eu montaria esse backend e onde ele começa a apertar. Se você curte ferramenta simples resolvendo problema difícil, vale a leitura.

#Bun #TypeScript #WebSocket #WebAssembly #GameDev