Cloud Gaming Glossary

WebAssembly is a binary instruction format designed as a portable compilation target for programming languages like C, C++, and Rust. It enables code to run in web browsers at near-native execution speeds — typically within 4–8% of native performance in benchmarks. The W3C standardized WebAssembly in 2019 as the fourth official web language, alongside HTML, CSS, and JavaScript.

For browser-based emulation, WebAssembly is the foundational technology that made high-quality emulation practical in a browser context. Emulation cores previously written in C or C++ for maximum native performance can now be compiled to WebAssembly and served over a CDN, allowing browsers to execute them with the same efficiency as native applications. RetroCloud's entire emulation infrastructure is built on WebAssembly-compiled emulation cores.

WebGPU is the successor to WebGL as the browser's GPU access API. Unlike WebGL, which wraps OpenGL ES 2.0 concepts, WebGPU is designed from the ground up around modern GPU architectures, providing explicit command buffers, pipeline state objects, and compute shader support. It shipped in Chrome 113 (2023) and subsequent versions of Edge, Firefox, and Safari.

For gaming applications, WebGPU reduces CPU-side rendering overhead by 30–45% compared to WebGL for scenes with many draw calls. Its compute shader support enables GPU-accelerated pixel format conversion, post-processing effects (scanline filters, CRT simulation), and other parallel GPU workloads that were too expensive to run in real time with WebGL.

Emulation is the process of replicating the behavior of one computing system (the target) using a different computing system (the host). An emulator simulates the target system's CPU instruction set, memory map, hardware registers, and peripheral behavior in software, allowing software designed for the target hardware to run unchanged on the host hardware.

Game console emulation aims to replicate original hardware behavior with sufficient accuracy that software designed for that hardware runs correctly and produces identical or near-identical output. Accuracy levels range from frame-accurate (correct behavior at the frame level) to cycle-accurate (correct behavior at the individual clock cycle level), with higher accuracy generally requiring greater computational resources.

A ROM mapper (also called a memory bank controller or MBC) is a chip present in game cartridges that enables the game to use more memory than the console's CPU address space would directly allow. The CPU has a fixed address space (16-bit on the NES, for example, providing 64KB of addressable memory), but later game cartridges contained multiple megabytes of program and graphics data. The mapper chip intercepts CPU memory accesses and routes them to the appropriate bank of ROM or RAM.

Emulators must implement the behavior of every mapper variant to correctly run the games that used them. The NES alone has over 400 documented mapper types. Mapper support breadth is the primary factor determining how many titles a given NES emulator can run correctly. RetroCloud's NES emulation supports 312 mapper variants, covering approximately 99.3% of the commercial library.

A save state is a complete snapshot of an emulator's internal state at a specific moment in time, capturing the contents of all emulated memory, CPU registers, hardware registers, and peripheral state. Loading a save state restores the emulation to exactly that moment — as if the game had never been paused. Save states are distinct from a game's built-in save functionality (battery SRAM saves), which only saves whatever the game's own save system writes.

Save state portability between emulators is a significant engineering challenge because save state formats are emulator-specific binary structures. RetroCloud addresses this with an abstraction layer that normalizes critical state components into a versioned, portable format, allowing graceful migration when emulation cores are updated.

Battery-backed SRAM (Static Random Access Memory) is the save mechanism built into cartridges from the NES era through the Game Boy Advance. A small lithium battery on the cartridge PCB maintains power to a dedicated SRAM chip, preserving the game's save data even when the console is powered off. This is the original save mechanism for games like The Legend of Zelda and Pokémon.

Unlike emulator save states, battery SRAM data is highly portable: it is simply the raw contents of the SRAM chip, which maps directly to a specific address range in the emulated hardware's memory. Any correctly written emulator will interpret this data the same way. RetroCloud stores battery SRAM data separately from full save states for maximum interoperability and long-term durability.

Delta compression is a technique that stores or transmits only the differences between two versions of data, rather than the complete data each time. In the context of cloud save synchronization, delta compression computes a binary diff between the current save state and the last successfully synchronized state, transmitting only the changed regions rather than the full state.

For typical gaming sessions where memory writes between saves are localized to small regions (inventory data, position data, progress flags), delta payloads are 3–8% of the full state size. RetroCloud's delta engine identifies changed 4KB page-aligned memory regions and packages them with a rolling hash for integrity verification, enabling save synchronization to complete in under 200ms on standard broadband connections.

A Content Delivery Network is a globally distributed network of servers (Points of Presence, or PoPs) that cache and serve content from locations geographically close to end users. CDNs reduce latency by eliminating the need for users to retrieve content from a single origin server that may be located on the other side of the world. For large binary assets like game ROMs and WASM emulation cores, CDN delivery can reduce load times from several seconds to under a second.

RetroCloud operates through a CDN network spanning 40+ points of presence globally. Game assets classified as immutable (fixed content that never changes) are cached with a one-year Cache-Control header and content-addressable URLs incorporating SHA-256 content hashes, guaranteeing freshness without periodic revalidation.

Edge computing refers to deploying computation and data processing at locations physically close to end users, rather than at centralized data centers. In web infrastructure, edge computing typically means running code at CDN points of presence — the same servers that serve cached content — enabling dynamic request processing with the low latency of a nearby cache server.

For gaming platforms, edge computing enables authentication validation, session initialization, and API routing to happen within milliseconds of the user's request rather than requiring a round-trip to a distant origin. RetroCloud deploys authentication and session initialization logic as edge functions, reducing session startup latency from ~180ms (origin round-trip) to under 30ms for users in supported regions.

WebRTC is a W3C and IETF standard that provides real-time communication capabilities directly between browsers, without requiring intermediate servers for the actual data exchange once a connection is established. It includes APIs for peer-to-peer audio, video, and data channel communication, along with an ICE (Interactive Connectivity Establishment) framework for negotiating the best available network path between peers.

In browser-based gaming, WebRTC's DataChannel API enables peer-to-peer multiplayer sessions by transmitting controller input states directly between players' browsers with UDP-like or TCP-like delivery semantics. RetroCloud's multiplayer implementation achieves direct peer-to-peer connections for approximately 70% of sessions, with the remaining 30% relayed through TURN servers when NAT traversal is not possible.

The iNES format is the de facto standard container format for NES ROM files. Developed in 1995 by Marat Fayzullin for the iNES emulator, the format prepends a 16-byte header to the raw ROM data describing the number of program and character ROM banks, the mirroring type, the presence of battery-backed RAM, and the mapper number. The mapper number is the most critical field, identifying which memory bank switching circuit the cartridge used.

The NES 2.0 format, a backward-compatible extension finalized in 2012, extends the mapper number to 12 bits, adds sub-mapper identification for variants of common mappers, and includes fields for submapper, ROM size extensions, and timing region. RetroCloud supports both iNES and NES 2.0 at ingestion, applying appropriate header interpretation for each format version.

No-Intro is a preservation project that maintains a canonical database of verified ROM dumps for cartridge-based gaming systems. The No-Intro methodology requires each entry to represent a bit-perfect copy of the original media verified across multiple independent dumping sources. Every entry is identified by CRC32, MD5, and SHA-1 hashes that allow any ROM file to be definitively matched against the database.

No-Intro's naming convention encodes region, language, revision, and release type in the filename (e.g., "Super Mario World (USA) (Rev 1).sfc"), enabling automated identification of region variants and revision differences. RetroCloud validates every catalog entry against the No-Intro database at ingestion time and does not serve titles that fail validation without human review.

Redump is the optical disc counterpart to No-Intro, providing verified dump standards and a canonical database for disc-based gaming systems including PlayStation, Sega Saturn, Dreamcast, GameCube, and others. A Redump-verified dump includes the disc data image, CUE sheet, sub-channel data, and expected component hashes for integrity verification at the component level.

Disc preservation is more complex than cartridge preservation due to mixed data and audio tracks, sub-channel data encoding copy protection information, and publisher-specific disc layouts. Redump's rigorous methodology ensures that preserved disc images accurately represent the original media and will behave correctly in emulation environments that rely on the preserved data being bit-accurate.

A Progressive Web App is a web application that uses modern browser capabilities to deliver an experience comparable to native apps: installability, offline functionality, background synchronization, push notifications, and hardware integration. PWAs require HTTPS, a Web App Manifest, and a Service Worker to qualify for browser installation prompts.

For gaming applications, PWAs enable installation to the home screen or OS app launcher, offline play via cached game assets and emulation cores, Screen Wake Lock to prevent sleep during sessions, and Gamepad API integration for controller support. RetroCloud's PWA implementation achieves 22% installation rate among monthly active users, with installed users showing 3.4x higher weekly session frequency than browser-only users.

IndexedDB is the browser's primary structured data store: an asynchronous, transactional object database supporting binary data (ArrayBuffers and Blobs), complex JavaScript object storage via structured cloning, indexed queries, and storage capacity limited only by available disk space. It is the correct API for storing game save data, user preferences, and metadata in browser gaming applications.

IndexedDB's transaction model ensures save data integrity: a write transaction either completes atomically or rolls back entirely, preventing partial saves. For gaming applications, this means a save operation that updates both the save file and its metadata record cannot result in one without the other, even if the browser is closed or the connection drops mid-write.

A Service Worker is a JavaScript file that runs in the background, separate from the web page, acting as a programmable network proxy. It intercepts all fetch requests from the page and can serve responses from a local cache, modify requests before they reach the network, or generate computed responses entirely without a network request. Service Workers are the technical foundation of PWA offline capabilities.

In gaming applications, Service Workers enable instant loading of the application shell from cache, offline access to previously downloaded game assets, and background sync for save state uploads when connectivity is restored after an offline session. RetroCloud's Service Worker uses a cache-first strategy for immutable application resources and a network-first strategy with cache fallback for dynamic catalog data.

Brotli is a lossless data compression algorithm developed by Google, designed specifically for HTTP content encoding. It achieves 15–25% better compression ratios than gzip for JavaScript and CSS files while maintaining comparable decompression speeds. Brotli is supported by all modern browsers and has become the preferred compression format for web text assets.

RetroCloud applies Brotli compression at level 11 (maximum) to all text-based assets at deploy time, storing pre-compressed files in CDN origin storage. This approach eliminates the per-request compression overhead that on-the-fly compression would require, while delivering maximum compression ratios to users. For users on slower connections, the bandwidth reduction from Brotli-over-gzip noticeably reduces load times for JavaScript-heavy emulation pages.

A JSON Web Token is a compact, URL-safe means of representing claims between two parties. A JWT consists of three Base64URL-encoded parts: a header describing the token type and signing algorithm, a payload containing the claims (user identity, permissions, expiration time), and a cryptographic signature verifying the token's authenticity and integrity. The signature allows any party with the public key to verify the token without querying a central authentication server.

RetroCloud uses short-lived JWTs (15-minute expiry) for API authentication, signed with RS256 (RSA with SHA-256). The stateless verification model is essential for edge authentication: edge functions can validate tokens locally without contacting the origin, reducing authentication latency to under 2ms at nearby PoPs. Token rotation on refresh and a token revocation list propagated to edge KV storage within 60 seconds provide security without sacrificing the performance benefits of stateless validation.

WebAssembly threading allows WASM modules to run across multiple threads using Web Workers and SharedArrayBuffer for inter-thread shared memory. SharedArrayBuffer provides a shared memory region that multiple threads can read and write to, coordinated using the JavaScript Atomics API for synchronization. This capability enables the CPU-intensive emulation core to run on a dedicated worker thread while the main thread remains responsive for rendering and input handling.

SharedArrayBuffer requires Cross-Origin Isolation (Cross-Origin-Opener-Policy: same-origin and Cross-Origin-Embedder-Policy: require-corp HTTP headers) due to browser mitigations for the Spectre side-channel vulnerability. RetroCloud implemented Cross-Origin Isolation in 2023, enabling multithreaded emulation that reduces main-thread rendering time by approximately 67% and eliminates audio glitching caused by main-thread contention.

Multi-Version Concurrency Control is a database concurrency technique that maintains multiple versions of data records simultaneously, allowing readers to access consistent snapshots of data without blocking writers. MVCC is the concurrency model used by PostgreSQL, CockroachDB, and many other production databases, and it underpins the conflict resolution system in RetroCloud's cloud save infrastructure.

When a save state conflict occurs — two devices attempting to write different versions of the same save simultaneously — RetroCloud's MVCC-based conflict resolution preserves both versions and surfaces them to the user for manual resolution. This approach is superior to last-write-wins strategies that silently discard one version of a user's game progress. The cost of this complexity is justified by the severe user impact of silent data loss for irreplaceable game progress.

The OpenAPI Specification (formerly Swagger) is a language-agnostic standard for describing HTTP API contracts in a machine-readable format. An OpenAPI document describes every endpoint's request and response schemas, authentication requirements, error conditions, and parameter types in a structured JSON or YAML format. This document can be used to generate API client SDKs, server stubs, interactive documentation, and automated test suites.

RetroCloud's API contract is defined in OpenAPI 3.1 format and serves as the single source of truth for both server-side implementation and client SDK generation. Using OpenAPI as the contract layer ensures that the documentation always reflects the actual API behavior (because the implementation is generated from the spec), and enables partner developers to use standard tooling to integrate with our platform. Any proposed breaking change requires a new OpenAPI major version and a 180-day deprecation period.

The token bucket is a rate limiting algorithm that models a virtual bucket containing tokens. Tokens are added to the bucket at a fixed rate (the refill rate) up to a maximum capacity (the burst size). Each API request consumes one token. If the bucket is empty, the request is rejected with a 429 Too Many Requests response. If the bucket contains tokens, the request is allowed and one token is consumed.

The token bucket's key advantage for gaming APIs is its natural accommodation of burst traffic. A client that has been idle for a period accumulates tokens (up to the bucket maximum) and can spend them in a burst — exactly matching the pattern of game session launch, which generates multiple API requests simultaneously. Tuning the refill rate and burst capacity independently allows precise control over sustained throughput and burst headroom for each partner tier.

ICE (Interactive Connectivity Establishment) is the framework used by WebRTC to negotiate the best available network path between two peers. ICE candidates represent potential connection paths: local network addresses, server-reflexive addresses discovered via STUN (Session Traversal Utilities for NAT), and relay addresses provided by TURN (Traversal Using Relays around NAT) servers.

STUN servers help peers discover their public IP addresses and port mappings assigned by NAT routers. TURN servers act as relay nodes when direct peer-to-peer connection is blocked by symmetric NAT or restrictive firewall configurations. RetroCloud operates TURN server infrastructure in each of its three cloud regions to ensure that multiplayer sessions remain functional even when direct peer connections are not possible — which accounts for approximately 30% of multiplayer sessions in production telemetry.

A vector clock is a distributed systems mechanism for tracking causality between events across multiple independent processes. A vector clock is a list of counters, one per participating process, that is incremented by a process when it performs an event and merged with other clocks when receiving messages. By comparing vector clocks, it is possible to determine whether two events are causally related (one happened before the other) or concurrent (neither happened before the other in a deterministic sense).

RetroCloud uses vector clocks to timestamp save state write operations across devices. When two devices write conflicting save states concurrently, the vector clocks identify the conflict definitively rather than relying on wall-clock timestamps, which may be incorrect due to device clock skew. This ensures that the conflict resolution system surfaces all genuine conflicts and never incorrectly discards a concurrent write as a redundant update.

AES-256 (Advanced Encryption Standard with 256-bit keys) is the encryption standard used for protecting data at rest in RetroCloud's storage infrastructure. AES-256 is a symmetric block cipher — the same key encrypts and decrypts data — widely considered the gold standard for data-at-rest protection, used by government agencies, financial institutions, and cloud providers globally.

RetroCloud applies AES-256 encryption at two layers for save state data: object-level encryption on individual save files, with keys managed through a hardware security module (HSM) and rotated quarterly; and storage-layer encryption at the volume level, providing defense in depth against physical media access. Users may optionally enable client-side encryption for their save data, in which case RetroCloud stores only ciphertext with no access to the decrypted content.

Anycast is a network routing methodology where the same IP address is advertised from multiple network locations simultaneously. Routers in the internet's BGP (Border Gateway Protocol) infrastructure direct traffic to the "nearest" anycast destination based on route metrics. From the user's perspective, they connect to a single IP address; the network transparently routes their packets to the geographically and topologically closest server advertising that address.

RetroCloud's CDN uses Anycast DNS routing to direct users to their nearest point of presence automatically. This eliminates the latency of an explicit DNS lookup round-trip to determine the nearest server — the anycast routing happens at the network layer, invisibly to the application. For users in regions with multiple nearby PoPs, anycast also provides automatic failover: if the nearest PoP becomes unreachable, routing shifts to the next closest without any application-level intervention required.

OpenTelemetry is an open-source observability framework that provides standardized APIs, SDKs, and tooling for collecting distributed traces, metrics, and logs from applications and infrastructure. A distributed trace follows a single request as it propagates through multiple services, recording timing and metadata at each step, enabling engineers to understand the full request path and identify bottlenecks or failure points in complex distributed systems.

RetroCloud's API infrastructure is fully instrumented with OpenTelemetry, with traces propagated across edge functions, origin services, database queries, and external API calls. When incidents occur, distributed traces allow the engineering team to reconstruct the complete request path within minutes. Trace data is retained for 30 days and used for both incident investigation and proactive performance analysis — identifying slow code paths before they become user-impacting problems.

Emscripten is a compiler toolchain that translates C and C++ code into WebAssembly (and optionally JavaScript). It provides a complete POSIX-compatible environment including a libc implementation, filesystem emulation, and bindings for browser APIs, allowing complex C/C++ applications to run in browsers with minimal code changes.

Emscripten is the primary tool for bringing existing C/C++ emulation cores to the browser. Most high-quality emulation cores are written in C or C++ for performance reasons, and Emscripten enables these same codebases to be compiled to WebAssembly for browser delivery. Modern Emscripten builds support SIMD intrinsics, threading via pthreads (implemented using Web Workers and SharedArrayBuffer), and WebGL integration, making it possible to compile sophisticated emulation cores with minimal performance compromise.

The Digital Millennium Copyright Act (DMCA) provides a safe harbor from copyright liability for online service providers who respond promptly to valid takedown notices from rights-holders. A rights-holder who believes their copyrighted content is being hosted without authorization can submit a takedown notice specifying the infringing content; the provider must remove the content to maintain safe harbor protection.

RetroCloud maintains a fully operational DMCA process with a designated agent registered with the Copyright Office. Valid takedown notices received before 5 PM local time are processed within 24 hours, with the affected content removed and the submitter notified. We also operate a counter-notice process for cases where content was removed in error. Our licensing-first catalog approach means that DMCA notices for catalog content are rare, as all catalog titles are either licensed or in the public domain.

The WebAssembly System Interface (WASI) is a standardized API specification that provides WebAssembly modules with access to operating system-level functionality — file system access, networking, clocks, and random number generation — in a platform-agnostic way. WASI enables WebAssembly modules to run outside the browser (in Node.js, Deno, cloud edge runtimes, or standalone WASM runtimes) while using the same compiled binary as the browser-targeted version.

For RetroCloud, WASI represents an architectural opportunity: a single WebAssembly-compiled emulation core could potentially run both in the browser (for client-side emulation) and in server-side edge functions (for server-side rendering, testing infrastructure, or cloud-based save state validation) without maintaining separate native and browser-targeted builds. WASI support in our emulation toolchain is an active area of investment for the RetroCloud infrastructure team.

Real User Monitoring (RUM) is the practice of collecting performance and behavior data from actual users in production, as opposed to synthetic monitoring (probing infrastructure from controlled environments). RUM data is collected using browser APIs — the Navigation Timing API for page load metrics, the Resource Timing API for individual asset load times, and the User Timing API for custom application-level performance marks.

RetroCloud uses RUM data as the primary driver for performance optimization decisions. Game launch time, measured from user click to first playable frame, is tracked as a primary product metric segmented by geographic region, browser type, device tier, and game system. Changes to caching policy, compression settings, or asset delivery architecture are validated by their measured impact on the RUM distribution before full rollout. This data-driven approach ensures that optimization investments target the performance gaps that matter most to real users in production conditions.