awesome-repositories.com
Blog
MCP
awesome-repositories.com

Discover the best open-source repositories with AI-powered search.

ExploreCurated searchesOpen-source alternativesSelf-hosted softwareBlogSitemap
ProjectMCP serverAboutHow we rankPress
LegalPrivacyTerms
© 2026 Bringes Technology SRL·VAT RO45896025·hello@awesome-repositories.com
EmulatorJS avatar

EmulatorJS/EmulatorJS

0
View on GitHub↗

AI search

Explore more awesome repositories

Describe what you need in plain English — the AI ranks thousands of curated open-source projects by relevance.

Start searching with AI
emulatorjs.org
↗

EmulatorJS

EmulatorJS is a WebAssembly emulation framework and RetroArch web frontend designed to run classic video game ROMs and BIOS files directly in a web browser. It serves as a web-based game emulator that executes hardware-accurate emulation cores to reproduce the behavior of various vintage home consoles and arcade systems.

The project is distinguished by its ability to synchronize game states between multiple users in real time using WebRTC for browser-based multiplayer gaming. It also includes a dedicated HTML5 game embed tool that generates code snippets and isolated containers to integrate playable emulators into third-party websites.

The framework covers a wide range of capabilities, including retro game library management with automated metadata tagging, custom input mapping for keyboards and gamepads, and the integration of custom visual shaders. It manages data persistence through automated save intervals and local browser asset caching to reduce network requests.

A built-in local development server is provided for testing the emulation environment.

Features

  • Web-Based Emulators - Executes classic video game ROMs and BIOS files directly in a web browser using hardware-accurate cores.
  • WebAssembly-Based Playback - Executes hardware-accurate emulation cores in the browser using WebAssembly for near-native performance.
  • ROM Collection Scanning - Scans and indexes ROM files to provide a searchable and organized interface for game libraries.
  • Netplay Synchronization Engines - Implements a networking layer that synchronizes game state and input timing across remote browser instances via WebRTC.
3,925 stars·936 forks·JavaScript·GPL-3.0·81 views
  • Retro Gaming Frameworks - Indexes game collections and automates metadata tagging for a searchable web-based interface of classic titles.
  • Real-Time State Synchronization - Synchronizes game state between multiple clients in real time using WebRTC for browser-based multiplayer gameplay.
  • WebRTC State Synchronization - Synchronizes game states between multiple users in real time using WebRTC for shared browser gameplay.
  • Emulator Resource Mapping - Provides comprehensive configuration for input mappings, visual shaders, and interface styles.
  • WebAssembly Frontends - Provides a browser-based interface for RetroArch cores executed via WebAssembly for high performance.
  • JavaScript Multi-Threading - Utilizes separate web workers and shared memory buffers to execute emulation cores without blocking the UI thread.
  • Virtual File System Mappings - Maps remote URLs and local archives to a simulated directory structure for emulator core asset access.
  • Emulation Core Frameworks - Implements a framework that integrates multiple hardware-accurate emulation cores into a single web-based frontend.
  • Embed Isolations - Provides isolated containers that prevent the emulator's styles and scripts from interfering with the host website.
  • Multiplayer Session Synchronizers - Synchronizes network sessions across multiple browser instances to facilitate real-time multiplayer interactions.
  • PSP Emulators - Implements JavaScript-based emulation to run PlayStation Portable titles in the browser.
  • Sega CD Cores - Includes selectable cores and BIOS support for emulating Sega CD games.
  • GameBoy - Emulates the GameBoy system architecture to run classic Nintendo titles.
  • Advance Cores - Uses the mGBA core to execute GameBoy Advance ROMs within a web browser.
  • User Preference Management - Manages user-specific settings for interface language, debugging tools, and application caches.
  • Embed Code Generators - Ships a utility that generates HTML code snippets for integrating playable emulators into third-party websites.
  • Metadata Tagging - Automatically identifies games and attaches descriptive tags from external sources to organize libraries.
  • Browser Storage Managers - Includes tools for managing and clearing local game data stored within browser-native storage APIs.
  • Web Asset Caches - Stores emulator cores, ROMs, and BIOS files in the browser's local storage to reduce network requests and startup time.
  • Asset Caches - Implements specialized caching of emulator cores and BIOS files in the browser to minimize redundant network requests.
  • JSON-Driven Configurations - Uses JSON configuration files to define input mappings, asset paths, and frontend interface preferences.
  • Asset Path Configurations - Allows definition of custom URLs for emulator assets to enable hosting via external storage or CDNs.
  • Emulator Save States - Allows capturing and restoring the complete binary state of emulator memory for immediate session resumption.
  • UI Sandbox Isolation - Integrates emulators into webpages using isolated containers to prevent style and script interference with the host site.
  • PlayStation Emulators - Provides specialized emulation cores and BIOS support for playing original PlayStation titles.
  • Commodore PET Cores - Provides a specialized emulation core to recreate Commodore PET hardware in a browser.
  • Commodore Plus/4 Cores - Implements a dedicated emulation core for running Commodore Plus/4 software.
  • Commodore VIC-20 Cores - Provides a specialized core to replicate Commodore VIC-20 hardware behavior.
  • Sega Game Gear Cores - Provides specialized emulation cores for running Sega Game Gear ROMs.
  • Sega Saturn Cores - Uses a WASM-based core and BIOS files to emulate Sega Saturn ROMs.
  • Custom Shader Programs - Integrates custom shader source code into settings to modify the visual output of the emulated game.
  • Nintendo 3DS Emulators - Ships with a multi-threaded core for rendering Nintendo 3DS titles in the browser.
  • Super Nintendo Emulators - Executes Super Nintendo Entertainment System ROMs using configurable cores and BIOS.
  • Nintendo 64 Emulators - Provides configurable cores for rendering Nintendo 64 ROMs with cross-platform compatibility.
  • Nintendo DS Emulators - Integrates compatible cores and BIOS support to execute Nintendo DS ROMs.
  • Remote Media Loading - Fetches emulator cores from remote servers to enable execution without local data hosting.
  • Emulated Input Mappings - Allows mapping physical keyboard and controller buttons to emulated machine inputs for up to four players.
  • Web-Worker Threading - Offloads emulator core execution to separate web workers with shared memory to prevent UI blocking.
  • BIOS Directory Configurations - Provides configuration settings to designate the directories containing required system firmware BIOS files.
  • Amiga Emulators - Includes a dedicated core for executing Commodore Amiga ROMs and BIOS files.
  • Nintendo Entertainment System Emulators - Executes Nintendo Entertainment System and Famicom titles using specialized hardware cores.
  • Sega 32X Cores - Provides a WebAssembly-based core for executing Sega 32X ROMs.
  • Sega Master System Cores - Offers selectable cores for the emulation of Sega Master System games.
  • Sega Mega Drive Cores - Provides selectable cores to run Sega Mega Drive and Genesis ROMs in the browser.
  • Commodore 64 Cores - Provides a dedicated emulation core to run Commodore 64 software in the browser.
  • Virtual File System Injections - Allows mapping external URLs or archives to specific locations within the internal virtual file system.
  • Automatic Save States - Implements periodic flushing of save files to disk at fixed intervals to prevent loss of game progress.
  • Game Controller Input Mappings - Provides default mappings for game controllers to translate physical inputs into virtual console actions.
  • Interface Appearance Customizations - Allows modification of the emulator's visual style and behavior through built-in configuration settings.
  • Interface Localization - Provides translation of the emulator interface into multiple languages for global accessibility.
  • Embeddable Player Generators - Creates the configuration files and code required to embed a specific game emulator into a web page.
  • Emulator Embeds - Generates HTML snippets and isolated containers to embed playable game emulators into external web pages.

    • Star history

    Star history chart for emulatorjs/emulatorjsStar history chart for emulatorjs/emulatorjs

    How this analysis was created: This summary and feature list are AI-generated from collected project material and can contain mistakes. Stars, license and language are imported from GitHub. Inclusion does not mean that we have tested or audited this project. Check the source documentation for any feature you depend on. Learn more on our About page.

    Frequently asked questions

    What does emulatorjs/emulatorjs do?

    EmulatorJS is a WebAssembly emulation framework and RetroArch web frontend designed to run classic video game ROMs and BIOS files directly in a web browser. It serves as a web-based game emulator that executes hardware-accurate emulation cores to reproduce the behavior of various vintage home consoles and arcade systems.

    What are the main features of emulatorjs/emulatorjs?

    The main features of emulatorjs/emulatorjs are: Web-Based Emulators, WebAssembly-Based Playback, ROM Collection Scanning, Netplay Synchronization Engines, Retro Gaming Frameworks, Real-Time State Synchronization, WebRTC State Synchronization, Emulator Resource Mapping.

    Which projects share features with emulatorjs/emulatorjs?

    Projects with overlapping indexed features include: rommapp/romm — Romm is a self-hosted game library manager and ROM management web interface. It serves as a central server for storing… swordfish90/lemuroid — Lemuroid is an Android multi-system emulator and Libretro frontend designed to run games from multiple vintage gaming… onionui/onion — Onion is a custom handheld gaming operating system and retro gaming frontend designed to manage and launch emulators… jhollingworth/bootstrap-wysihtml5 — bootstrap-wysihtml5 is a rich text editor that integrates with the Bootstrap CSS framework to provide a visual… blinkospace/blinko — Blinko is a personal knowledge management system and an LLM-powered knowledge base that enables users to capture and… veloren/veloren — Veloren is an open-source multiplayer RPG featuring a voxel-based action adventure in a procedurally generated fantasy…

    Projects sharing features with EmulatorJS

    These projects share indexed features with EmulatorJS. Shared tags can include platform or build tooling; verify the primary use case before treating a result as a replacement.
    • rommapp/rommrommapp avatar

      rommapp/romm

      7,824View on GitHub↗

      Romm is a self-hosted game library manager and ROM management web interface. It serves as a central server for storing and categorizing game files and emulator firmware, providing a web-based browser to organize collections through automated library scanning and metadata retrieval. The project distinguishes itself by integrating a web-based emulator frontend that uses WebAssembly to play games directly in the browser. It further provides a game save synchronization server that uses SSH-based synchronization to transfer save states and progress between the server and registered handheld device

      Pythonemulationopen-sourceretrogaming
      View on GitHub↗7,824
    • swordfish90/lemuroidSwordfish90 avatar

      Swordfish90/Lemuroid

      3,989View on GitHub↗

      Lemuroid is an Android multi-system emulator and Libretro frontend designed to run games from multiple vintage gaming systems through a single interface. It functions as a retro gaming library manager that scans local storage for game files and organizes them into a searchable catalog. The application includes a cloud-synced save manager to preserve game progress across different devices via remote storage. It also features a virtual gamepad interface that allows for custom input mapping across physical controllers, tilt sensors, and on-screen touch overlays. Additional capabilities cover ga

      Kotlin
      View on GitHub↗3,989
    • onionui/onionOnionUI avatar

      OnionUI/Onion

      4,193View on GitHub↗

      Onion is a custom handheld gaming operating system and retro gaming frontend designed to manage and launch emulators on portable hardware. It functions as a bootable custom firmware distribution and emulation environment manager that replaces factory software to provide an integrated gaming environment. The system distinguishes itself through a modular core-based emulation architecture, allowing for the installation of verified emulator packages, BIOS configuration, and the use of hardware-specific drivers and filters. It also supports the integration of third-party game ports via standardize

      Cemulator-frontendmiyoo-minimiyoomini
      View on GitHub↗4,193
    • jhollingworth/bootstrap-wysihtml5jhollingworth avatar

      jhollingworth/bootstrap-wysihtml5

      4,118View on GitHub↗

      bootstrap-wysihtml5 is a rich text editor that integrates with the Bootstrap CSS framework to provide a visual interface for formatting HTML content. It functions as a localizable web editor and an HTML content parser that filters and validates tags and attributes to ensure clean content output. The project features a customizable rich text interface that allows for the modification of the toolbar and overall visual presentation through external stylesheets and HTML templates. It includes support for custom locale definitions and translated interface labels to accommodate international users.

      JavaScript
      View on GitHub↗4,118
    Compare all 30 related projects→