Skip to main content
Core Engine: Decompiled Binary → WebAssembly Runtime

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.

Decompilation Analysis WebAssembly Linear Memory WebGL / WebGPU Shaders Web Audio Worklets

* Independent systems engineering. Third-party software titles, assets, and trademarks belong to their respective copyright holders.

runtime-pipeline.spec
ASM → WASM
// 01: NATIVE DISASSEMBLY x86-64 / Win32 / POSIX
CALL 0x0041A9B0 ; EngineMainLoop()
ptr_ctx: 0x7FFF982A • DirectSound8: Hooked
// 02: BROWSER COMPATIBILITY LAYER WASM + AudioWorklet
LinearMemory: 64MB growable page buffer
Renderer: WebGL2 / Canvas surface blit
EventLoop: requestAnimationFrame sync
Status: In Active Engineering Slovakia • 911bob.dev
Core Initiative

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.

Ghidra / IDA Decompilation AST Analysis

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.

Virtual FS & Memory Model WASM Shim Layer

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.

Compatibility Tooling Developer SDK

> 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.

Porting Philosophy:
✓ Zero plugin dependencies
✓ Deterministic frame updates
✓ WebAssembly native speed
✓ Clean architectural abstraction
Architecture Overview

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)

Deterministic

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.

Legacy Desktop Architecture
VirtualAlloc() / VirtualProtect()
Arbitrary physical OS pointer offsets
Potential segfaults & memory leaks
Browser Runtime Implementation
WebAssembly.Memory + DataView
Clamped zero-overhead buffer bounds
Thread-safe SharedArrayBuffer sync
Technical Hard Problems

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.

01 / DISASSEMBLY AST Analysis

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.

Target: Class hierarchy & vtables
02 / MEMORY Linear Address Space

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.

Target: WASM 64KB page allocator
03 / GRAPHICS WebGL2 / WebGPU

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.

Target: 60 FPS shader pipelines
04 / AUDIO AudioWorklet

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.

Target: <15ms buffer latency
05 / INPUT Gamepad & Pointer

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.

Target: Raw mouse lock & gamepads
06 / STORAGE Virtual Filesystem

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.

Target: In-memory VFS & OPFS
Code-Level Realities

Decompilation & Shim Inspection

Compare the raw, decompiled native logic against our typed, sandboxed browser compatibility implementations.

src/compat/video_backend_shim.cpp
Mode: Side-by-Side 100% Zero-Crash Boundary
[1] DECOMPILED D3D9 / WIN32 PSEUDOCODE IDA Pro / Ghidra Pass
// 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);
}
[2] BROWSER COMPATIBILITY LAYER (WASM / WEBGL2) Zero-allocation blit
// 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);
}
Methodology & Tooling

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.

PHASE 01

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
PHASE 02

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
PHASE 03

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
PHASE 04

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
About 911bob Labs

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.

Authentic Engineering
We prioritize working binaries and verified frame parity over marketing noise.
Open Web Standards
Targeting standard WebAssembly, WebGL2, and Web Audio without proprietary runtimes.
Studio Profile Active Operations
Studio: 911bob Labs
Location: Slovakia 🇸🇰 (Central Europe)
Core Focus: Binary Decompilation & Web Porting
Specialization: Systems & Web Runtime Engineering
Primary Domain: 911bob.dev
Note on Intellectual Property: Our porting research is an independent clean-room engineering effort. All trademarks, game titles, and original assets remain the property of their respective copyright owners.
Get in Touch

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.

hello@911bob.dev
Response time: <24 hours • PGP available on request
Copied to clipboard