About Dusty Bytes

Classic games, preserved and playable in your browser.

What is this?

Dusty Bytes is a browser-based retro gaming platform. Classic PC games from the 90s — compiled to WebAssembly and running natively in your browser. No downloads, no plugins, no emulators. Just open a URL and play.

Each game runs using its open-source engine reimplementation, compiled to WebAssembly so that it can run directly in the browser. The original game data (shareware and demo editions) provides the assets. The platform shell handles rendering, audio, input, and save persistence — the games think they're running on native hardware.

Architecture

The platform runs entirely in your browser — there is no game server. Each game engine is compiled to WebAssembly and runs inside an isolated Web Worker thread. The main browser thread handles all input, rendering, and audio, while the Worker handles game logic. The two communicate through a message-passing bridge — the game engine never touches the DOM directly.

Main Thread (Platform Shell) Web Worker (per-game) ├── Canvas rendering (putImageData) ├── Game engine (WASM) ├── Web Audio API ├── Emscripten runtime ├── Input capture + serialization ├── Virtual filesystem (MEMFS) ├── Touch controls (mobile) └── Save sync (IDBFS) ├── Asset cache (OPFS) ├── User-supplied game files (OPFS) └── Save persistence (IndexedDB)

This message-passing architecture provides complete isolation — a crash in one game engine cannot affect the browser tab. Frame data is sent as transferable ArrayBuffers for zero-copy performance. The platform shell is game-agnostic: the same rendering, audio, and input code serves all four engines.

All four engines use the same threading model: ASYNCIFY cooperative yielding on the Emscripten main thread inside their Worker. The game's realtime callbacks (audio fill, render, input pumps) run synchronously; any blocking call (event waits, frame sleeps) yields control back to the Emscripten runtime so the rest of the WASM module keeps making progress. No engine uses native pthreads or SharedArrayBuffer.

How games are loaded

How it works

Full versions, disk to engine, Diablo as the example.

1. OPFS — the browser's private filesystem. When you drop DIABDAT.MPQ on the upload area, your browser stores it in the Origin Private File System (OPFS). OPFS is a sandboxed storage area bound to dustybytes alone — no other site can read it, and the file never crosses the network. The bytes live in your browser profile, keyed under /user-games/diablo-full/DIABDAT.MPQ.

2. Main thread reads OPFS. When you click Play, the platform's main JavaScript thread opens the file from OPFS and reads it into an ArrayBuffer.

3. Zero-copy to the engine's Web Worker. The game engine runs in a separate thread — a Web Worker — to keep the main UI responsive. We hand the buffer over using the structured-clone transfer protocol, which moves ownership of the underlying memory rather than copying it. For a 493 MB file, that's a meaningful win.

4. Emscripten MEMFS — a virtual filesystem in RAM. Inside the worker, the engine is C++ code compiled to WebAssembly via Emscripten. Emscripten provides a virtual filesystem called MEMFS — essentially a tmpfs that lives in the WASM module's linear memory. We write the bytes to MEMFS at the path the engine expects (/DIABDAT.MPQ for devilutionX).

5. WASM reads MEMFS as if it were disk. From the engine's point of view, MEMFS is just a filesystem with files. It calls fopen() / fread() like it would on Windows or Linux, and the WASM runtime routes those calls into MEMFS. The C++ code is unchanged from its desktop original — it has no idea it's running in a browser.

Saves work in reverse. When the engine writes save files, those go to IDBFS, an Emscripten filesystem backed by your browser's IndexedDB. That persists across refreshes — so your save survives.

Why this design

Input + Mobile

On desktop, keyboard and mouse events are captured, serialized, and forwarded to the Worker. On mobile, a configurable touch control system translates gestures into game inputs:

Networking

Every game runs entirely client-side — there is no game server, no matchmaking, no cloud sync. Each browser tab is its own self-contained universe. Adding multiplayer would mean building a unified networking stack across all four engines (likely WebRTC for peer-to-peer, with a small signaling server for player discovery). That's on the wishlist; not built yet. For now, every game is single-player.

Tech Stack

Engine Attribution

Each game runs through an open-source engine reimplementation. We maintain Emscripten/WASM forks with minimal patches on top of the upstream projects. Full patch history is available in the fork branches linked below. Engines are listed in release order of the games they power.

Stratagus + Wargus
Powers the Warcraft II (1995) entries.
GPL-2.0
GNU General Public License v2. Free to use, modify, and redistribute — modifications must be released under GPL-2.0. See upstream COPYING for full terms.
devilutionX
Powers the Diablo (1996) entries.
Sustainable Use License
Source-available license. Free for personal use; commercial use restricted. See upstream LICENSE for full terms.
fallout1-ce
Powers the Fallout (1997) entries.
Sustainable Use License
Source-available license. Free for personal use; commercial use restricted. See upstream LICENSE for full terms.
Xash3D FWGS + hlsdk-portable
Powers the Half-Life (1998) entries. Xash3D is the engine; hlsdk-portable is the Half-Life game DLL component, built alongside it.
GPL-3.0 + Half-Life 1 SDK License
Xash3D FWGS is GPL-3.0 (free to use, modify, and redistribute; modifications must be released under GPL-3.0; see upstream COPYING). hlsdk-portable uses Valve's proprietary Half-Life 1 SDK License (free non-commercial use and distribution of games built with the SDK; redistribution must include the LICENSE file).

Game Data Ownership

Dusty Bytes ships only freely distributable demo and shareware editions of game data — official releases that the original publishers made available at no cost:

No full-game copyrighted data is hosted or distributed. If you own a full copy of these games, the platform can load it locally — your files never leave your device.

Privacy

Dusty Bytes has no accounts and no sign-up — there's nothing to register for. We don't currently run analytics or tracking scripts of any kind.

Full-game data you upload (Diablo's DIABDAT.MPQ, Fallout's master.dat, etc.) is written to your browser's Origin Private File System (OPFS) and never leaves your device — it is not uploaded to any server. Save games persist locally in your browser via IndexedDB. If that changes — for example, if we add privacy-respecting analytics like Cloudflare Analytics — this section will be updated to reflect it.

Trademarks

Dusty Bytes is an independent project. Not affiliated with, endorsed by, or sponsored by Blizzard Entertainment, Valve Corporation, Interplay Entertainment, or any other publisher mentioned. All trademarks, game titles, character names, and brand assets are the property of their respective owners.

DMCA / Copyright

If you believe content on this platform infringes your copyright, please send a notice to contact@dustybytes.com. Include: the copyrighted work at issue, the allegedly infringing URL, your contact information, and a statement of good faith belief.