Porting complex native software to the modern browser.
We are 911bob Labs, an independent systems engineering team in Slovakia. We reverse-engineer legacy C/C++ game engines and reconstruct native platform dependencies—memory architectures, audio pipelines, graphics routines, and real-time event loops—into zero-install, high-performance web browser runtimes.
* Independent systems engineering. Third-party software titles, assets, and trademarks belong to their respective copyright holders.
ptr_ctx: 0x7FFF982A • DirectSound8: Hooked
Renderer: WebGL2 / Canvas surface blit
EventLoop: requestAnimationFrame sync
Native Game Re-engineering & Browser Compatibility
Modern web browsers provide near-native execution capabilities through WebAssembly, WebGL2, and AudioWorklets. However, bridging a legacy compiled game from native desktop code to the browser requires solving fundamental differences in memory models, synchronous platform APIs, and execution runtimes.
Decompiled Code Analysis
Deconstructing compiled x86 binaries, mapping undocumented internal struct layouts, virtual method tables (vtables), and state machine transitions into structured, verifiable representations.
Browser-Native Runtime
Rebuilding native operating system bindings (Win32 message loops, POSIX file handles, memory pointers) as browser-compatible subsystems targeting WebAssembly linear memory and DOM events.
Developer Tooling & Workflows
We are productizing our compatibility workflows, struct verification harnesses, and shim generators into reusable toolsets to accelerate how engineering teams port and preserve native software on the modern web.
> Why Browser Porting Matters
Decades of video game history and interactive software are locked behind outdated operating system interfaces, abandoned runtime libraries, and bit-rotting native drivers. Emulators can be heavy and inflexible. Native browser ports bring instant zero-install accessibility, instant cross-platform execution on phones, laptops, and tablets, and long-term digital preservation on open web standards.
Subsystem Translation Pipeline
How legacy desktop architecture translates into modern web primitives without losing frame accuracy or introducing latency.
Memory Management & Raw Pointers
Direct 32-bit/64-bit Address Space → WebAssembly.Memory (ArrayBuffer)
Native C++ engines rely on unchecked pointer arithmetic, packed struct alignment, and manual heaps (malloc / free). In the browser sandbox, arbitrary host memory access is impossible. We model the native address space inside an isolated 32-bit WebAssembly Linear Memory page pool, allowing legacy pointer calculations to execute at native hardware speed while remaining completely sandboxed.
Engineering Challenges
Porting a compiled desktop codebase isn't a matter of re-running a compiler. It requires systematically untangling decades of implicit operating system assumptions.
Decompiled Code Analysis
Legacy executables lack debug symbols and source comments. We reconstruct C++ class hierarchies, recover struct member offsets, and map cryptic compiler-generated control flow into clean, verifiable logical units.
Unaligned Pointer Operations
Native x86 CPUs tolerate unaligned 32-bit reads; WebAssembly and SIMD can throw hardware traps or introduce penalties. We ensure memory layouts are strictly aligned within our WASM linear memory heap.
Renderer Subsystem Rehosting
Transforming legacy immediate-mode drawing and Direct3D state changes into batched draw calls and modern GPU render passes, maintaining original color space, blending formulas, and pixel-grid fidelity.
Realtime Audio Synchronization
Replicating circular sound buffers without stutter or latency. We run dedicated AudioWorklet threads that pull audio frames from shared ring buffers independently of the main browser event loop.
Precision Input Compatibility
Translating low-level keyboard scan codes, mouse delta coordinates, and controller rumble into modern Pointer Lock and Gamepad API signals, eliminating input lag and browser shortcut collisions.
Synchronous I/O in Async Runtimes
Legacy code assumes fopen() blocks and completes instantly. Browsers only support asynchronous fetches. We implement pre-indexed virtual filesystems (VFS) with memory-mapped assets.
Decompilation & Shim Inspection
Compare the raw, decompiled native logic against our typed, sandboxed browser compatibility implementations.
// Offset 0x0042FE10: PresentSurface()
int Engine_RenderFrame(void* ctx) {
struct RendererState* s = *(RendererState**)((char*)ctx + 0x28);
if (!s || !s->pD3DDevice) return -1;
// Lock raw backbuffer video memory
D3DLOCKED_RECT rect;
s->pSurface->LockRect(&rect, NULL, 0);
// Unaligned pitch blit to primary display buffer
memcpy(rect.pBits, s->pPixelBuffer, s->pitch * s->height);
s->pSurface->UnlockRect();
return s->pD3DDevice->Present(0, 0, 0, 0);
} // Reconstructed surface binding for HTML5 Canvas
export function renderFrameBrowser(wasmHeap: Uint8Array, ptr: number): void {
const pixels = wasmHeap.subarray(ptr, ptr + FRAME_BYTE_LEN);
// WebGL2 texture sub-image replacement
gl.bindTexture(gl.TEXTURE_2D, frameTexture);
gl.texSubImage2D(
gl.TEXTURE_2D, 0, 0, 0,
1280, 720,
gl.RGBA, gl.UNSIGNED_BYTE, pixels
);
// Composite pass with linear-filtering shader
gl.drawArrays(gl.TRIANGLE_STRIP, 0, 4);
} Iterative Engineering & AI-Assisted Analysis
Legacy reverse-engineering is notoriously time-consuming and error-prone. We combine rigorous systems engineering practices with modern AI-assisted codebase comprehension tools to accelerate decompilation and verification.
Subsystem Boundary Isolation
Rather than attempting a monolithic port, we sever tight platform couplings at clear architectural boundaries: input, graphics, audio, filesystem, and game simulation. Each subsystem is verified independently with isolated mock drivers before browser integration.
- • Clean HAL (Hardware Abstraction Layer) interfaces
- • Mock environments for headless integration testing
AI-Assisted Code Comprehension
We leverage advanced AI coding assistants, notably Claude Code, to parse and analyze hundreds of thousands of lines of decompiled pseudocode. AI models assist in recognizing compiler optimizations, recovering struct fields, and generating type definitions.
- • Pattern recognition across obfuscated control-flow graphs
- • Automated synthesis of typed C++ and TypeScript shims
Parity Verification & Differential Testing
How do we know the browser port behaves identically? By running differential execution traces. We log deterministic state snapshots (PRNG seeds, collision boxes, game state hashes) and compare the native binary's memory against the WebAssembly runtime frame-by-frame.
- • Golden master snapshot comparison
- • Regression tests for memory corruption and leaks
Generalizing into Developer Tooling
The difficulties we solve—Win32 API translation, audio ring buffer shimming, and asset packing—are shared across hundreds of legacy preservation efforts. We are designing our compatibility modules to be modular and reusable for other developers and archivists.
- • Reusable platform abstraction modules
- • CLI workflows for decompiled struct mapping
Systems engineering studio based in Slovakia.
911bob Labs is an independent software development studio based in Slovakia. We specialize in low-level systems programming, reverse engineering, and modern web platform capabilities.
Our mission is to bridge complex native software—particularly desktop game engines compiled in C/C++—into zero-install, high-performance web runtimes without compromising framerates, memory safety, or user experience.
Alongside our primary browser-porting engine, we develop modular compatibility layers and developer tooling that streamline binary analysis, memory abstraction, and web subsystem translation for engineering teams and digital preservation projects.
Let's talk systems & web engineering.
Whether you are interested in our compatibility architecture, exploring collaboration opportunities, or evaluating custom web-porting solutions for legacy codebases, our inbox is open.