NFSU2 no navegador: o que o Bun tem a ver com isso
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:
- Um servidor de assets estáticos grandes, com cache agressivo.
- 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