A list of emulators written in the JavaScript programming language.

This list started as a compilation of JavaScript emulators posted to Echo JS over the years. If you know about any missing emulators, please consider adding them to the collection: the source for this page is available on GitHub. Thank you in advance.

• Atom Tiny Emu - by Andre Weissflog (source)
• Acorn Atom Emulator - by Phil Mainwaring. Software archive here. (Older version here: Type "OLD" for an Easter Egg.)
• ElkJS - JavaScript based Acorn Electron emulator (Source)
• JSBeeb - JavaScript BBC Micro emulator (Source) (Development blog)
• JSAtom - JavaScript Acorn Atom emulator including Software Archive (Source) Based on JSBeeb

• MITS Altair Simulator Front panel simulation of the 8080-based Altair, by Ian Davies, built on 8080.js

• CPCBox - Amstrad CPC emulator in JavaScript (archive link)
• CPC Tiny Emu - by Andre Weissflog (source)
• Roland - An Amstrad CPC emulator written in JavaScript. (Source)

• Apple 1js - by Will Scullin
• Apple2e - Apple IIe emulator by John Clark (Source)
• Apple IIjs - An Apple ][ Emulator in JavaScript
• a2 - A fast, WebGL optimized Apple ][ emulator
• Apple2JS - A JavaScript emulator for the Apple II
• BasiliskII - An Emscripten Port of BasiliskII (Demo 1, Demo 2)
• MiniVMac-Em - An Emscripten Port of MiniVMac (Demo)
• Yet Another Apple 2 in JavaScript - by Thomas Skibo

• 8bit Workshop - VCS IDE by Steven Hugg, building on Javatari.js
• EstyJS - A pretty fast and functional JavaScript Atari ST emulator (Source)
• Javatari.js - Atari 2600 emulator by Paulo Augusto Peccin. (Example cartridges online) (Source)
• jsA8E - JavaScript version of the A8E Atari 800 XL Emulator
• JS7800 - JavaScript Atari 7800 Emulator

• Commodore LCD emulator - by Gábor Lénárt "LGB"
• Commodore PET - by Thomas Skibo
• JSC64 - Commodore 64 emulator written in JavaScript (Source)
• c64js - Commodore 64 emulator written in JavaScript by Mikael Borgbrant (Source)
• C64 Tiny Emu - by Andre Weissflog (source)
• Kim1 - emulation in JavaScript by Rob Sayers (Source)
• SAE - Scripted Amiga Emulator (Source)
• VIC-20 Emulator - JavaScript VIC-20 emulator
• VICE.js - Versatile Commodore Emulator for JavaScript (Source)

• Novas Are Forever - by Wild Hare Computer Systems, for the 50th anniversary.

• PDP-1 running the SpaceWar game and the Minskytron demo - by Norbert Landsteiner
• PDP-8 and PDP-11 simulators with assembly language interfaces (explanatory articles with full source, not live site) - by programmer209
• JavaScript PDP 11 - PDP-11/70 emulator with simulated front panel and a choice of operating systems. By Paul Nankervis
• PDP-11 Emulator - A JavaScript PDP-11 emulator running UNIX Sixth Edition. By Julius Schmidt
  • with teletype - PDP-11 emulator with teletype interface
• pdp11-js - PDP-11 emulator with UNIX V6. By Takahiro Aoyagi (Source)

• 1964js - JavaScript port of the 1964 N64 emulator for Windows
• CfxNES - JavaScript NES Emulator (Demo)
• CycloaJS - JavaScript NES Emulator (Source)
• em-fceux - an Emscripten port of FCEUX, an emulator of NES, Famicom, Famicom Disk System (FDS), and Dendy consoles. Demo site
• GBA.js - Game Boy Advance in the Browser (Source)
• IodineGBA - A Game Boy Advance emulator written entirely in JavaScript (Source)
• gba.ninja - JavaScript port of VisualBoyAdvance-M, a Game Boy Advance emulator (Source)
• JSNES - A JavaScript NES emulator (Source)
• NESNES - JavaScript NES emulator, also available as a web component (Source)
• Nezulator - A NES emulator in JavaScript
• N64Wasm - A web based N64 Emulator (Source)
• XNES - Experimental JavaScript Super Nintendo emulators (Source)
• jsGB - A Game Boy emulator in JavaScript (Source)
• jsGBC - Game Boy Color Emulator written in JavaScript (Source)
• mupen64plus - A port of the popular Nintendo 64 emulator for the Web (Source)
• n64js - An N64 emulator in JavaScript (Source)
• pinky - A Rust based NES emulator ported to the web via WebAssembly (Source)
• DeSmuME-wasm - A WebAssembly port of the DeSmuME Nintendo DS emulator (Demo)
• Desmond.js - A portable/embeddable version of DeSmuME-wasm (Demo)
• SkyEmu - SkyEmu is a low level Game Boy, Game Boy Color and Game Boy Advance emulator
• CAMLBOY - A Game Boy emulator that runs in your browser written in OCaml
• TinyGB - A Game Boy emulator that runs only in the terminal written in NodeJS
• Boytacean - A Game Boy emulator written in Rust that works in the Browser using WebAssembly (Source)

• KC85_Emu - KC85/3 and KC85/4 emulator by Alexander Lang
• KC85/2 family emulators by Andre Weissflog (source):
  • KC85/2 Tiny Emu
  • KC85/3 Tiny Emu
  • KC85/4 Tiny Emu
• LC-80 - single board U880-based trainer from the DDR (warning: auto-plays sound at boot), via emscripten. By Andre Weissflog (source)
• Z1013 Tiny Emu - by Andre Weissflog (source)
• KC87 Tiny Emu - by Andre Weissflog (source)

• jsSMS - JavaScript Sega Master System & Game Gear emulator (Source)
• Miracle - Sega Master System emulator (Source)

• JSSpeccy - A ZX Spectrum emulator in JavaScript (Source)
• JtyOne Online ZX81 Emulator - by Simon Holdsworth
• Qaop/JS - ZX Spectrum emulator
• ZX80 Emulator - JavaScript ZX80 Emulator
• EMF ZX80 - EMF-based ZX80 Emulator - by Steven Goodwin (@MarquisdeGeek) (Source)
• EMF ZX81 - EMF-based ZX81 Emulator - by Steven Goodwin (@MarquisdeGeek) (Source)
• Science of Cambridge MK14 simulator - by Doug Rice, based on Paul Robson's offline emulator.
• ZX Spectrum 48K Tiny Emy - by Andre Weissflog (source)
• ZX Spectrum 128 Tiny Emu - by Andre Weissflog (source)

• eNGE - JavaScript browser based PSX emulator (runs games at full speed) (Source)
• PSeudo - JavaScript/WebGL/WebAudio browser based PLAYSTATION emulator (aka PSX) (needs boot ROM image, not supplied) (Source)
• PCSXjs - Modified PCSX-Reloaded compiled with Emscripten (Source)
• WASMpsx - Easily embeddable fork of PCSXjs
• kpspemu - PSP Emulator written in Kotlin for JVM, JS and Native
• Play!.js - This is a port of Play!, a PlayStation2 emulator, running in a web browser

• CloudT TRS-80 Model 100 Emulator - by John R. Hogerhuis (Announcement)
• MC-10 Emulator - Emulator for the TRS-80 MC-10 microcomputer
• TRS-80 Model III Emulator a JavaScript emulator for the TRS-80 Model III, by Peter Phillips
• JS Mocha - The HTML5 CoCo 2 Emulator

• JSMESS examples - The JavaScript MESS (Multi Emulator Super System) (Source) (Notes)
• PCE - PC emulators in JavaScript (Atari ST, IBM PC 5150, Macintosh, RC759 Piccoline)
• RetroArch - JavaScript port of RetroArch (bundles Gambatte (Game Boy), Genesis Plus GX, Handy (Lynx), Snes9x Next, VBA Next (Game Boy Advance), Tyrquake and FinalBurn Alpha)
• RetroWeb - collection of JavaScript emulators and boot media, including Apple-IIe (VisiCalc), Macintosh (System 1.0), Atari 1040ST, Commodore 64, Amiga 500 (Workbench 1.3), IBM PC Model 5150 (PC-DOS, CP/M-86, Cassette Basic), IBM PC XT (DOS, GEM 1.2, VisiCalc, Windows 1.01, 8088 Corruption demo), RC759 Piccoline (Eliza, Bil-simulation, Concurrent CP/M-86), TRS-80.
• YAKC - Z1013, Z9001, KC85/2 family, Speccy, CPC, Acorn Atom, C64, with integrated debugging UI (source)
• Tiny Emulators - based on the same chip- and system-emulator source code as YAKC, but as minimal WASM apps without fluff (source)
• EmulatorJS - RetroArch compiled to emscripten with a nice wrapper (source)

• Em-DOSBox - An Emscripten port of DOSBox (Demo)
• Halfix - x86 PC emulator that runs both natively and in the browser, via WebAssembly (Demo 1, Demo2)
• js-dos - WebAssembly port of DOSBox (fork of Em-DOSBox with better js API) (Demo,Source)
• JS/Linux - JavaScript PC emulator
• JsDOSBox - JavaScript PC DOS emulator (Source)
• PCjs - IBM PC Model 5150 emulator (Source)
• QemuJS - An Emscripten port of QEMU (Demo)
• Virtual x86 - x86 virtualization in your browser, recompiling x86 to wasm on the fly (Source)
• jemul8 - An object-oriented JavaScript x86 emulator for Node.js and the Browser (Source)
• jsbochs - Bochs PC emulator for the Browser (Source)
• Boxedwine - An emulator that runs Windows applications using Wine and emulating a Linux kernel and CPU (Source)

• 8008 running SCELBAL by Mark G. Arnold. ("SCELBAL is the only open-source, floating-point, high-level language ever implemented on the 8008")
• 8080 CPU emulator - Intel 8080 CPU emulator running Space Invaders ROM (Source)
• AVR8js - AVR architecture emulator, capable of running Arduino code (source)
• EMF Arcade Invaders - EMF-based 8080 Emulator with Space Invaders ROM - by Steven Goodwin (@MarquisdeGeek) (Source)
• 8086tiny running FreeDOS - An Emscriptem port of Adrian Cable's 8086tiny. Source, and other emulators ported by Clay Shippy, at https://github.com/tecan/emscripten-projects.
• Angel - JavaScript RISC-V ISA simulator booting Linux in a web-browser
• Angular 2 6502 written with TypeScript and Angular 2, by Jeremy Likness
• ARM-js - An ARM emulator written in JavaScript (Source)
• ASM80 - Online assembler for 8-bit microprocessors by Martin Malý. Includes emulation of several machines: 8080, Z80, 6502, 6809. (Sources)
• Basic MIPS functional simulator by Mianzhi Wang (morriswmz). (Source)
• Easy6502 - JavaScript 6502 tutorial and emulator (Source)
• EduMIPS64 - Educational MIPS64 CPU, ported from Java by Andrea Spadaccini using GWT (see blog here.) (Source)
• FRISCjs - an 8-register educational RISC from the University of Zagreb, with both assembler and front panel, by Ivan Žužak. Source
• Imaginary 6502 - 6502 Emulator and Assembler
• Intel 4004 emulator - by Maciej Szyc. Includes assembler and disassembler.
• Intel 8080 CPU Emulator - Emulates a minimal Intel 8080 Microcomputer that runs CP/M
• iRISC - Interactive ARMv7 assembly language interpreter and computer architecture simulator (Source)
• JavaScript 8080 Emulator - 8080 arcade game emulator in JavaScript
• Mipsdis - MIPS disassembler that runs in the browser
• RISC Relay Computer - Relay based computer project with a 16 bit RISC CPU. Emulator includes an assembler and source for a calculator program. By RJH. See website.
• RISCVEMU - RISC-V emulator boots 64-bit Linux. By Fabrice Bellard.
• RP2040js - Raspberry Pi Pico (RP2040 / Arm Cortex-M0 ) emulator with C/C /MicroPython/CircuitPython support (Source)
• Simple 8-bit Assembler Simulator - Provides a simplified assembler syntax (based on NASM) and is simulating a x86 like CPU (Source)
• uARM.wasm - ARMv5TE emulator running Linux in browsers (Source)
• Unicorn.js - The Unicorn emulator framework, now available for JavaScript (Source)
• Visual ARM1 - JavaScript/WebGL for ARM's first CPU, modelling 25000 transistors at switch level and animating the original chip layout - in 3D. See the blog post
• Visual 6502 - JavaScript simulator for the 6502 CPU, modelling thousands of transistors at switch level and animating the original chip layout. See also expert mode.
• Visual 6800 - JavaScript simulator for the Motorola 6800 CPU, modelling thousands of transistors at switch level and animating the original chip layout.
• Visual Z80 - JavaScript simulator for the Z80 CPU, modelling thousands of transistors at switch level and animating the original chip layout.
• Visulator - x86 machine emulator that visualizes how each instruction is processed (Source)
• YAMD - Yet Another MIPS Debugger (Source)
• jor1k - OpenRISC OR1K JavaScript emulator running Linux with network support (Source)
• jslm32 - JavaScript LatticeMico32 emulator running Linux (Source)
• ZUSIE - JavaScript simulation of Fredrik Andersson's homebrew relay machine inspired by Zuse's machines.

• Babbage's Difference Engine (First funded 1823, first full build in 1855, first full rebuild in 1991)
• Babbage's Analytical Engine in JavaScript, by John Walker. (First described 1837, never completed, not yet rebuilt.) (Documentation)
• Turing machine simulated in JavaScript. See here for more information. (1936)
• Z1 machine's adder in 3D JavaScript/WebGL interactive simulation of the mechanical adder of Zuse's first machine. By Jakob Mischek (Source) (1938)
• Z3 machine's adder - ripple-carry electromechanical adder simulated in JavaScript, by Henry Raymond, Patrick Seewald and Vijeinath Tissaveerasingham. Explanation (1941)
• JsSSEM - Manchester Small-Scale Experimental Machine emulator (Also check Computer/zero which is very loosely based on the SSEM, and its tutorial) (1948)
• C88 - C88 computer simulation (The Homebrew CPU inspired by the SSEM) (1948)
• EDSAC on Browser - by NISHIO Hirokazu (Programming guide) (1949)
• EMF Elliott - EMF-based Elliott Emulator - by Steven Goodwin (@MarquisdeGeek) (Source)
• WITCH Emulator - The Harwell Dekatron Machine, by Justin King. (Source and example programs) (1951)
• UNIVAC I emulator - JavaScript emulator by Norbert Landsteiner (1951)
• ElectroData/Burroughs Datatron 205 Emulator - by Paul Kimpel (Source) (1954)
• TX-0 emulator by @wizforest, including several programs from the time. (Instructions) (1956)
• Mailüfterl - JavaScript emulator by Norbert Kehrer (1958)
• Setun (Russian) and English (archived) - JavaScript emulator by Обухов Александр. Ternary machine from Soviet Union (1958)
• Digi-Comp 1 (previously) - educational sliding-rods plastic computer. Emulator by Larry Groebe and Kevin Williams. (1963)
• Digi-Comp II - educational falling-marbles computer. Emulator by Joda Redfearn. (1965)
• Burroughs B5500 emulator - Burroughs B5500 emulator in JavaScript (Source) (1964)
• Apollo Guidance Computer - Moonjs a port by Shahriar Iravanian of Ronald Burkey's Virtual AGC. (1966)
• BESM-6 - with examples in Algol, Fortran, and assembler. By Leonid A. Broukhis and Michael Yaroslavtsev. More here. (1968)
• CARDIAC - Bell Labs' CARDIAC cardboard computer from 1969. Instructions (1969)
• Kenbak-1 - John Blankenbaker's TTL-based 256byte personal computer. More information (1970)
• Ordinapoche - A paper computer from France, invented 1969, popularised in 1981 and 1985. (More here and see also the 1981 magazine)
• BullGammaTor - A JavaScript emulator for the Bull Gamma 3 ET computer (Source) (1952)

• HP21u, HP25u, and HP29u - by Greg Sydney-Smith
• HP-35 - bug-compatible emulator by Ashley Feniello explained here using Eric Smith's and Jacques Laporte's work
• HP-35, HP-45, HP-55, HP-65, HP-80 - collection of HP Classics, based on Feniello's work, by Francois Roulet
• HP-45 - statically recompiled ROM by Norbert Kehrer
• jsEmu48 - emscripten port by Julien Meyer of HP EMU By Daniel Nilsson. (Source)
• HP-55, HP-65 and HP-67 - with extra debug menu, by Greg Sydney-Smith
• мк-61 - Elektronika's programmable calculators MK-61, Б3-34, МК-54, and МК-56, also the Феликс-М (Felix M) arithmometer, a slide rule and an abacus. By Felix Lazarev, Andrey_emu, Sergey Tarasov and others.
• Sinclair Scientific and TI-1500 - calculator simulations including full description of the algorithms and the reverse-engineering process. By Ken Shirriff. Further work by Phil Mainwaring shows Sinclair Cambridge, TI-1500 and Sinclair Scientific, each using different customisations of TI's 080x chip.
• TI-42 "MBA" Programmable Calculator by Jeff Parsons (PCjs)
• TI-55 by Jeff Parsons (PCjs)
• TI-57 Programmable Calculator by Jeff Parsons (PCjs)
• TI-92 Plus emulator - JavaScript emulator for the TI-92 Plus
• JavaScript TI-89 / TI-92 / TI-V200 / TI-89T emulator - by Patrick Davidson and Lionel Debroux

• HP-11C, HP-12C Platinum, HP-16C - by Elvis Pfützenreuter
• HP-16C (Jovial RPN) - by Bill Foote
• HP-15C - by Greg Hewgill. (Source)
• HP-21 and HP-29 by Greg Sydney-Smith (See here and here)
• HP-25 - by John Clenance
• HP-35 - JavaScript emulator by Neil Fraser
• HP-35 SOS - modified HP-35 with stack overflow sensing LED, by Hans Klaver, based on Fraser's work
• HP-48 - JavaScript implementation of the most commonly used HP-48 functions. More info here, by Josh Poley
• Olivetti Programma 101 - JavaScript emulation of the first commercial programmable desktop computer, by "Fabioamd87". Source on GitHub
• Sinclair Cambridge Programmable by Nigel Bromley. (Source here.)

• C1Pjs - JavaScript simulation of the Challenger 1P (PCjs)
• Canon Cat (in JSMess) - Jef Raskin's Forth-capable 68000-based word processor. (Instructions and more info)
• CFT - JavaScript simulation of Alexios Chouchoulas' 16-bit homebrew TTL machine. (More information including documentation and a video.)
• Chip-8 virtual machine by Alexander Dickson - see blog entry
• Chip-8 virtual machine by Brian Milton (Source may target several CPUs)
• Chip8 1k - a code-golfed chip 8 emulator in 1k by Maxime Euzière and others
• EMF Chip 8 - EMF-based Elliott Emulator - by Steven Goodwin (@MarquisdeGeek) (Source)
• EMF Megaprocessor - EMF-based Megaprocessor Emulator - by Steven Goodwin (@MarquisdeGeek) of the room-sized machine built by James Newman and housed in the Museum of Computing History, in Cambridge, England. (Source)
• Merry8 - JavaScript Chip-8 emulator by Yifeng Wang
• Compucolor II Emulator - JavaScript Compucolor II Emulator
• Compukit UK101 - by David Stevenson
• ContrAltoJS - Pure JavaScript implementation of the ContrAlto Xerox Alto emulator (Source)
• COSMAC Elf-ish - simulator by William Donnelly
• DCMO5 Online - Thomson MO5 JavaScript emulator
• Dodo Playground - IDE and simulator for 6502-based Dodo homebrew game system by Peter Noyes
• EMF Dragon - EMF-based Dragon Emulator - by Steven Goodwin (@MarquisdeGeek)
• EMF Jupiter Ace - EMF-based ZX80 Emulator - by Steven Goodwin (@MarquisdeGeek) (Source)
• Enterprise-128 JavaScript Emulator - by Gábor Lénárt "LGB", based on JSSpeccy
• ESP8266 Game Engine - a console-game-oriented virtual machine running on ESP8266, by Corax. (Source)
• Gigatron - emulator of the present-day TTL console computer with Tiny Basic and games. Also Wozmon on a nested emulation of 6502. (Website)
• Hack - emulator of the computer from nand2tetris, by diversen. (Source.)
• Heathkit ET3400 - by Phil Mainwaring. Click "Do" then "0000". (Instructions)
• IBM 5110 Emulator by Norbert Kehrer runs Basic or APL.
• JS99'er - TI-99/4A emulator written in JavaScript (Source)
• jsH89 - Heathkit H89 emulator (runs CP/M) by Mark Garlanger
• JSGS - Experimental JavaScript implementation of the Pico-8 fantasy console (Source)
• jsMSX - The first MSX emulator 100% written in JavaScript
• JsPspEmu - JavaScript PSP emulator (Source)
• JSVecX - JavaScript port of the VecX Vectrex emulator
• jupiler - Jupiter Ace emulator written in JavaScript (Source)
• KM-Z80 web emulator for Sharp MZ-80K, by Katsumi Morimatsu. GOTO $1200 to start KM-BASIC. (More information)
• laser500emu emulator for Video Technology (VTech) Laser 350/500/700, by Antonino Porcino.
• Little Man Computer a minimal CPU for teaching - emulator by Matthew Krutar. (Background)
• Little Man Computer a minimal CPU for teaching - emulator by Paul Hankin. (Background)
• Little Man Computer a minimal CPU for teaching - emulator by Peter Higginson. (Background)
• Machine in a machine - Turing Machine Implementation in 1k from the JS1k competition
• Marmmodore-1K - minimal 8-bit computer in 1k by Felipe Alfonso
• NanoWasp - A MicroBee emulator
• Nascom 2 emulator by Tommy Thorn. (J to start Basic) (Source)
• One Instruction Set Computer (OISC) by Peter Crampton, presented by Brian L. Stuart. (Explanation)
• Orao - Orao emulator by Hrvoje Cavrak (More information)
• Oricutron - An emulator for the ORIC series of home computers, by Peter Gordon (Source)
• PC-01 Lviv - An emulator for the PC-01 Lviv (Ukrainian home computer) (Source)
• RISC Simulator - RISC Simulator with Fetch/Execute and register based CPU model, by Peter Higginson
• RockyJS - Pebble watch interpreter/emulator
• Radio-86RK Radio-86RK emulator in JavaScript (Intel 8080 based 8-bit Russian home computer) (Source)
• Setunka - Ternary computing for the browser
• SAP-1 JavaScript emulation of the Simple As Possible TTL machine from Malvino's book, Digital Computer Electronics. By Kenneth Ellis McCall. (Source)
• Tejotron - Virtual breadboard, inspired by Ben Eater's 6502 computer
• Turbo Pascal - A web-based Pascal compiler that runs a subset of Turbo Pascal 5.5 code
• Vector06js - Vector-06C (AKA Вектор-06Ц) JavaScript emulator by Viacheslav Slavinsky. Also runnable here. (Source.)
• Virt.js - JavaScript emulation library (Source)
• Visual Computer a minimal CPU for teaching by Shimon Schocken. (Web site)
• WebMSX - WebMSX, or simply WMSX, is a new MSX emulator designed for the Web (Source)
• Wireworld computer - JavaScript port by Salvatore Aiello of the prime-generating computer implemented in the Wireworld cellular automaton, as described here.
• WPCEmu - Williams Pinball Emulator by Michael Vogt

• Emscripten ScummVM - Emscripten fork of the ScummVM engine
• IFVMS - Infocom/Inform Web interpreter
• Parchment - Infocom/Inform Web interpreter
• ZZTJS - ZZT game engine in JavaScript
• ngPAWS - Professional Adventure Writer (PAW) Web interpreter

• A Big List of Browser-Based Emulators by Richard Moss
• Qaop/JS – Emulator links by Jan Bobrowski

This resource collection is maintained by Frederic Cambus.

• Site: https://www.cambus.net

To the extent possible under law, Frederic Cambus has waived all copyright and related or neighboring rights to this work.