How Does The Delta Emulator Work?

The Delta emulator works by leveraging a modular architecture that combines a user-friendly iOS interface with powerful, open-source emulation "cores".

These cores are the highly optimized software components responsible for replicating the hardware of classic video game consoles. Delta acts as a central hub, managing these specialized cores and providing a consistent experience for the user on iOS and iPadOS.

The emulation process: A multi-layered architecture

Delta's operation is best understood by breaking it down into its core components and the emulation process they facilitate.

1. DeltaCore: The central nervous system

• The middleware:DeltaCore is a specialized framework that sits between the app's native user interface and the low-level emulation cores. Its purpose is to standardize how the emulator interacts with different console cores, abstracting away the complexities of each unique system.
• Feature management: This framework is what provides access to all of Delta's signature features. When you create a save state, enter a cheat code, or customize a controller skin, DeltaCore is handling that request and translating it for the specific emulation core in use.

2. The emulation cores: The hardware whisperers

• Console-specific engines: The true "magic" of emulation happens within these specialized cores, which are often mature, community-developed open-source projects. Instead of having to develop an emulator for each system from scratch, the Delta team integrates these proven cores as submodules.
• How they work: An emulation core contains code that interprets and executes the machine code from a game's ROM file. It simulates the original console's:
  • CPU: The core translates the original system's processor instructions into code that the host device's (iPhone's) processor can understand and execute.
  • PPU (Picture Processing Unit) and GPU: The core simulates the original graphics hardware to render the game's visuals, which are then displayed on the iPhone's screen.
  • Sound hardware: It reproduces the audio from the original console, providing the nostalgic sound effects and music.
  • Input devices: It takes button presses from the user (via touchscreen or controller) and feeds them to the emulated system as if they were coming from a physical controller.

3. Roxas and Harmony: The secret sauce

• Roxas: This is a private framework developed by Delta's creator to handle common iOS development tasks. It streamlines processes and simplifies a variety of functions for the Delta app.
• Harmony: Another private framework, Harmony is specifically for syncing data. This allows Delta to listen for changes to its internal database (which tracks games, saves, and settings) and synchronize those changes with cloud services like Dropbox or Google Drive. This is the feature that allows you to start a game on your iPhone and seamlessly continue it on your iPad.

The user experience workflow

From the player's perspective, this complex, layered system works effortlessly. The workflow is as follows:

1. Importing a ROM: The user adds a game's ROM file (the digital copy of the game) to the app.
2. Core selection: Delta's UI recognizes the file type (e.g., .nds for Nintendo DS) and assigns the appropriate emulation core (melonDS in this case).
3. Core configuration: If necessary (like with DS games), Delta will prompt the user to provide specific BIOS files, which are essential system software from the original console.
4. Emulation starts: When the user selects the game, Delta uses DeltaCore to load the ROM file into the assigned emulation core, starting the emulation process. The UI displays the chosen controller skin, and the core begins to process the game data.
5. Running the game: The core runs the game, sending video and audio output to the iPhone's screen and speakers. It concurrently monitors for user input, whether from the on-screen overlay or a connected Bluetooth controller.
6. Using advanced features: Features like save states, fast-forward, and cheat codes are not handled directly by the emulation core. Instead, DeltaCore intercepts these requests from the user interface and translates them into commands for the active core. For example, a "save state" command tells the core to freeze its current state and dump all of its emulated memory to a file, which is then managed by the Delta app.
7. Cloud syncing: While playing, Harmony works in the background, listening for changes to your saves or other data and syncing them with your chosen cloud service.

The importance of modular design

Delta's modular architecture is key to its success and flexibility.

• Efficiency: It allows the developers to focus on the iOS-specific parts of the app, like the user interface, controller skins, and syncing, rather than reinventing the wheel with complex emulation programming.
• Accuracy and compatibility: By using battle-tested emulation cores, Delta ensures a high level of accuracy and game compatibility. Any improvements or bug fixes to these open-source cores can be integrated into Delta, keeping it up to date.
• Expandability: This design makes it easier to add support for new consoles in the future. The developer would only need to integrate a new emulation core that can communicate with the existing DeltaCore framework.