mamedev/mame

Features

• Retro Gaming Frameworks - Functions as a comprehensive framework for organizing ROM sets, managing disk images, and preserving legacy gaming hardware.
• Vintage Software Execution - Executes legacy software from arcade boards and computers using precise simulated hardware and media types.
• Hardware Emulators - Simulates physical hardware components, including CPUs, MCUs, and SOCs, for full system emulation.
• Automation And Scripting - Interacts with emulated memory and input systems via scripting for custom automation and analysis.
• Disk Image - Compresses raw disk and media images into a standardized format to optimize storage for legacy archives.
• System Capability Extensions - Integrates plugins that add new operational capabilities to the core system logic.
• Game ROM Organization - Structures and loads software image files specifically for launching game titles.
• ROM Set Management - Organizes game data using parent and clone sets to significantly reduce disk space.
• Hunk-Based Storage - Uses a standardized compressed hunk format to emulate large disk images without loading entire files into memory.
• Debugging and Inspection Tools - Provides interactive tools to inspect memory, registers, and execution flow using breakpoints and disassembly.
• Hardware Catalogs - Provides a searchable and filterable catalog of hardware and software configurations for selecting emulation targets.
• Emulation State Scripting - Allows custom logic and scripts via an interactive console to control the emulation session and system state.
• Vintage Display Simulation - Uses shaders and filters to recreate visual artifacts of vintage monitor hardware, such as CRT scanlines.
• Emulated Input Mappings - Provides interfaces for routing physical host input devices to virtual hardware components in the emulation environment.
• Hardware Dependency Management - Manages essential binary assets like BIOS images required for hardware emulation.
• Hardware Signal Emulation - Translates physical controller inputs into the specific electrical or logical signals required by original software.
• Software List Launching - Organizes and launches emulated systems and software using a graphical interface based on standardized software lists.
• Vintage Circuitry Emulation - Recreates low-level physical electronic circuits from arcade games and home computers to run original software.
• Vintage Hardware Simulation - Reproduces the physical and electrical behavior of legacy computing components and peripherals for preservation.
• Address Resolution Mapping - Implements mechanisms for translating logical addresses to physical hardware handlers in emulated systems.
• Virtual Bus Definitions - Defines logical address and data buses that allow emulated hardware components to communicate.
• System Debugging - Inspects memory, registers, and execution flow in real-time using breakpoints to analyze low-level software behavior.
• CPU Core Implementations - Provides specific software implementations of processor architectures, including the 6502 family, ensuring timing accuracy.
• Cycle-Accurate Bus Timing - Simulates hardware bus contention by introducing precise timing delays and wait states for cycle-accurate behavior.
• Emulation Session Control - Manages the lifecycle and execution state of the emulated hardware, including starting, pausing, resetting, and stopping.
• Execution Flow Control - MAME resumes processing until a specific condition is met, such as hitting a breakpoint or timer.
• Hardware Input Bindings - Binds physical host device inputs directly to emulated hardware I/O ports using digital and analog mappings.
• Hierarchical Address Mapping - Resolves logical addresses to physical devices through a hierarchical tree of memory zones and decoding handlers.
• Memory Banking Implementation - Implements hardware memory banking to allow a single address range to map to multiple physical memory banks.
• Memory Interface Modeling - Simulates the low-level hardware interface between the CPU and memory, distinguishing between opcode and data reads.
• ROM Asset Auditing - Verifies ROM assets against checksums and specifications to ensure image correctness and compatibility.
• ROM Data Access - Provides low-level mechanisms for reading data from emulated ROMs across various bit-widths.
• Mass Storage Emulation - Implements simulation of high-capacity storage devices using specialized compressed hunk formats.
• Intermediate Representations - Converts guest CPU instructions into a portable intermediate representation before generating host-executable machine code.
• Interactive Scripting Environments - Provides a real-time interactive Lua environment to execute commands and control system state.
• Lua APIs - Exposes core system state and hardware controls to an embedded Lua scripting engine for custom behavior.
• Program Counter Tracking - MAME records visited program counter addresses and highlights them in disassembly views to analyze paths.
• Emulated Memory Access - Provides capabilities to read and write values to emulated device address spaces.
• Modular Plugin Architectures - Employs an architectural framework designed for extensibility via a modular plugin system.
• Plugin-Based Logic Extensions - Loads external plugins to execute custom logic for modifying input, data handling, and system presence.
• Lua-Based Plugin Architectures - Implements a Lua-based plugin architecture to automate tasks and extend functionality after system boot.
• Automation Layers - Provides an embedded Lua engine to expose core system state and hardware controls for custom automation and analysis.
• Instruction Tracing - MAME logs processor instructions to a file with options to skip subroutines or include data.
• Delta Image Management - Reduces storage requirements by using delta files that reference a parent disk image for shared content.
• SCSI Controller Implementation - Provides cycle-accurate simulation of the physical control and data lines of SCSI controller chips.
• Pixel-Level Image Manipulation - Provides low-level manipulation of bitmaps, textures, and color palettes using ARGB formats.
• Visual Effects And Rendering - Employs shaders and effects engines to replicate the visual properties of original hardware displays.
• Compressed Hunk Compression - Compresses raw media images and hard disks into a standardized compressed hunk format to optimize storage.
• Compressed Image Extraction - Decompresses data from compressed hunk (CHD) images back into original raw or disk formats.
• Emulated Memory Exports - Exports ranges of emulated memory to text files as formatted data or ASCII representations.
• Disk Image Format Translation - Translates between various on-disk image file formats and internal magnetic state representations.
• Breakpoint Managers - Provides an interface to configure and manage breakpoints at specific memory addresses for CPU inspection.
• Disassembly Annotations - Attaches and manages custom text comments at specific memory addresses within the disassembly view.
• Command Line Configuration - Provides tools for modifying video and sound configuration parameters via command-line arguments.
• Configuration Search Paths - Provides mechanisms for locating configuration files across different system directories using search path order.
• Debugger Expression Parsers - MAME parses and executes tokenized expressions using symbol tables to resolve named variables and addresses.
• Debugger Interfaces - MAME manages the overall execution and state of the debugger interface to monitor emulated hardware.
• Diagnostic Logging - MAME prints formatted messages or symbol values to the console, error log, or trace file.
• Automated Test Execution - Executes automated test suites to verify the accuracy and stability of emulated hardware.
• Asset Dependency Diagnosis - MAME lists missing ROM dumps and disk images and displays the search paths attempted.
• Hardware Module Selection - Allows including or excluding specific video, audio, and network output modules to match the target environment.
• Resource Resolution Hierarchies - Uses prioritized search paths and directory hierarchies to locate required software and assets.
• Input Recording and Playback - Saves user input sequences to files and replays them to reproduce specific emulation sessions.
• Instruction Stepping Tools - MAME executes instructions one by one with options to step over calls or step out of functions.
• Memory Pattern Searching - Scans specified memory ranges for sequences of strings, numeric values, or wildcards to analyze software state.
• Memory String Extraction - Extracts NUL-terminated or custom-delimited strings from binary emulated memory and saves them to text files.
• Symbol Table Inspection - Implements utilities for querying and listing registered symbols and their current values within the emulated system.
• System State Automation - Provides an embedded Lua engine to expose core system state and hardware controls for custom behavior and analysis.
• Boot Sequence Automation - Runs scripts and plugins during the boot sequence to automate system setup and configuration.
• Hardware State Inspection - Enumerates the device tree and allows reading or writing to processor registers and memory for real-time monitoring.
• Configuration File Loading - Implements mechanisms for scanning and parsing structured configuration files to determine runtime behavior.
• Disk Image Integrity Validation - Performs CRC checking and identification to verify the correctness and format of disk images.
• Emulation State Management - Creates and restores snapshots of the emulated machine state to and from disk.
• Multiplayer Input Assignments - Organizes hardware controls into distinct player positions to support simultaneous multi-user interaction.
• Effects Processing - Modifies final audio output using an implementation of filters, compressors, reverb, and equalizers.
• Display Configuration Managers - Adjusts display modes, aspect ratios, and scaling filters to match original hardware.
• Multi-Screen Rendering Controllers - Maps game screens to physical monitors using custom rendering chains to apply different filters.
• Display Visual Adjustments - Controls brightness, contrast, gamma, and visual overlays like scanlines for the display.
• Display Hardware Interfacing - Interacts with display systems, including raster screens, vector displays, and color palette translations.
• Visual Effect Shaders - Implements custom GPU shaders to simulate specific display technologies and enhance visual fidelity.
• Video Rendering Management - Selects the rendering backend and manages window size, resolution, and aspect ratio.
• Vintage Acoustic Simulation - Applies sonic filters and effects to audio streams to recreate the acoustic characteristics of vintage hardware.
• Vector Display Simulations - Simulates the unique visual characteristics of original vector hardware, including beam intensity and flicker.
• Controller Mappings - Loads custom button and axis mappings from text files to ensure consistent game controller behavior.
• Emulated I/O Port Management - Provides mechanisms for configuring and reading data from simulated vintage hardware input and output ports.
• Hardware Slot Configuration - Defines and instantiates child hardware devices within specific slots to customize the emulated architecture.
• Input Remapping - Implements capabilities for substituting one physical input key or button for another across the control configuration.
• Input Control Assignment - Maps physical input devices to virtual system inputs using logical boolean combinations.
• Input Macros - Simulates rapid repeated inputs for specific buttons using a plugin-based macro system.
• Input Sequence Macros - Triggers a customizable series of emulated hardware inputs using a single key or button combination.
• Keyboard Key Mappings - Associates physical keyboard inputs with specific emulated hardware functions using mapping files.
• Media Playback Simulation - Simulates the physical transport mechanisms of legacy media, such as starting and stopping cassette tape drives.
• Memory Range Mirroring - Duplicates a physical memory range across multiple logical addresses using bitmasks for hardware fidelity.
• View Multiplexing - Allows dynamically switching between different submaps of a memory range at runtime.
• Archive Media Loading - Allows loading of ROM dumps and disk images directly from archives without manual extraction.
• Binary Disassembly - MAME translates binary opcodes from processor cores into human-readable assembly language and metadata.
• Binary Dump Comparison - Verifies binary dump consistency using hash functions and checksums to ensure data integrity.
• Binary Memory Dumping - Exports specific ranges of emulated memory directly to binary files for external analysis.
• Binary Memory Loading - Writes the contents of binary files directly into specified emulated memory ranges or address spaces.
• Intermediate Language Translation - Converts guest CPU instructions into an intermediate language to generate host-executable machine code.
• Instruction Interruption Support - Allows pausing CPU instructions mid-execution to simulate precise hardware wait states and interrupts.
• Conditional Breakpoints - Halts execution and activates the debugger when specific register expressions evaluate to true.
• CPU Variant Implementations - Provides specialized software implementations of different processor versions and offshoots of a specific architecture.
• Disk Image Format Manipulation - Processes and converts compressed, cassette, and floppy image files into formats compatible with emulated hardware.
• Disk Image Sector Editing - Provides low-level reading and writing of data to specific sectors of disk image files for hardware manipulation.
• Emulation Speed Optimizations - Adjusts frameskip, throttling, and CPU threading to maintain full speed or benchmark performance.
• Emulation State Rewinding - Captures and restores sequential snapshots of emulated state to allow backward stepping in time.
• Emulation Timing Control - Coordinates frame drawing and input processing with speed throttling to ensure accurate emulation timing.
• Execution Speed Controls - Controls frame skipping, clock throttling, and processor allocation to balance performance and accuracy.
• Execution State Recording - Records, plays back, and rewinds the system state to return to previous points in a session.
• External Media Mounting - Enables loading of specific files or archives as emulated media via direct paths.
• Hardware Dependency Resolution - Links emulated hardware devices and memory regions based on unique tags to establish system connections.
• Input Profile Managers - Allows saving and loading custom controller configuration profiles to quickly switch between input setups.
• Hardware Resource Grouping - Organizes similar emulated hardware devices or ports into indexable arrays for bulk access.
• Hardware Resource Validation - Verifies required hardware components and dependencies during system initialization.
• Hardware State Exposure - Exposes emulated hardware state changes to external programs via named outputs and multi-dimensional arrays.
• Host Function Interfacing - Triggers external functions, debugger breakpoints, and instruction hooks during the execution of emulated code.
• Keyboard Input Modes - Switches between natural typing translation and emulated digital input modes for system keyboards.
• Host-to-Guest Translation - Manages emulated keyboard and keypad devices to translate host keystrokes into legacy hardware inputs.
• Media Asset Location - Searches directories and archives for required files using filename, CRC, or content digests.
• Memory Content Manipulation - Enables overwriting blocks of emulated memory with specified data sequences or strings for debugging.
• Memory Map Exporting - Records the current logical-to-physical memory mapping configuration of emulated devices to a log file.
• Processor State Preservation - Saves and restores the full set of registers to and from a memory structure.
• ROM Hardware Mapping - Associates read-only memory regions with specific hardware buses to simulate chip data retrieval.
• Shared Memory Management - Allocates named memory zones that can be mapped into multiple virtual address spaces for hardware simulation.
• Sound Hardware Interfacing - Manages the input and output of audio data through low-level emulated sound hardware devices.
• System Memory Inspection - Provides tools for enumerating and analyzing the organization of memory banks, shares, and regions in emulated hardware.
• Device Property Querying - Provides programmatic interfaces for locating and retrieving properties of emulated hardware components.
• Floppy Disk Emulation - Simulates the physical properties and controller logic of floppy disk drives, including magnetic surface states.
• Instruction Flow Control - Manages low-level program traversal using labels, jumps, and subroutine calls within emulated code.
• Hierarchical Configuration Systems - Uses a configuration system that organizes settings into parent-child relationships for per-game and per-system inheritance.
• State Snapshots - Captures and restores the complete set of processor registers and memory regions to disk or RAM.
• Application Parameter Configurators - Provides command-line arguments to define internal application behavior and operational parameters.
• Exception Breakpoints - Triggers debugger breakpoints specifically when a processor raises a designated exception number.
• Memory Access Interception - Provides mechanisms to install taps on emulated address ranges to monitor or modify data during CPU access.
• Runtime Parameter Tuning - Adjusts software and hardware behavior parameters via built-in menus and configuration files during execution.
• Memory Access Breakpoints - Halts execution and activates the debugger when a processor accesses a specified memory range.
• Memory Access Tracing - Provides detailed logging of program counters during writes to specific memory locations for data-flow analysis.
• Plugin-Based Architectures - Integrates external logic and custom functionality via a modular architecture for specialized hardware or interfaces.
• Emulated Time Tracking - Monitors and reports the total elapsed time within the emulated environment relative to the host clock.
• Reverse Execution Simulation - MAME displays recently visited addresses and restores previous RAM states to simulate reverse execution.
• System Usage Monitors - Reports real-time device metrics including uptime, coin counters, and detailed hardware information.
• System Event Monitors - Registers callbacks to trigger specific logic when the emulated system is reset, stopped, paused, or resumed.
• SCSI Bus Emulation - Simulates the SCSI bus architecture, including device ID assignment and bus synchronization.
• SCSI Device Emulation - Implements SCSI target devices, such as disks and scanners, by handling SCSI command buffers.
• Execution Profilers - Tracks the stack depth of operations to analyze and debug software performance through runtime analysis.
• Refresh Rate Synchronization - Integrates with adaptive sync technologies to match the monitor's refresh rate to the software's output.
• Peripheral Hardware Simulation - Simulates non-standard external hardware interactions such as barcode scanners and cassette tape mechanisms.
• Layout Logic Scripting - Embeds scripts into layout files to implement complex logic and animate visual parameters.
• Screen Orientation Management - Rotates or flips the display to match original hardware orientation or fit a modern monitor.
• UI Input Interfaces - Processes high-level input signals specifically designed for interacting with system menus and user interfaces.
• XML Layout Definitions - Uses XML files to define the structural arrangement and positioning of emulated screens and artwork.
• Game Emulators - Accurate arcade cabinet emulation.

Star history