Keyboard Mapping

PC Key	Spectrum Key
A-Z, 0-9	Standard keys
Ctrl	Caps Shift
Alt	Symbol Shift
Enter	Enter
Space	Space / Break
Backspace	Delete (Ctrl+0)
Arrow Keys	Cursor (Ctrl+5/6/7/8)

PC Shift is free for regular shifted characters (!@#$%^&*etc)
Keys use physical QWERTY positions - works with any keyboard layout.

Symbol Shift Combinations (Alt + Key)

Keys	Symbol	Keys	Symbol	Keys	Symbol
Alt+1	!	Alt+Q	<=	Alt+A	~
Alt+2	@	Alt+W	<>	Alt+S	|
Alt+3	#	Alt+E	>=	Alt+D	\
Alt+4	$	Alt+R	<	Alt+F	{
Alt+5	%	Alt+T	>	Alt+G	}
Alt+6	&	Alt+Y	[	Alt+H	^
Alt+7	'	Alt+U	]	Alt+J	-
Alt+8	(	Alt+I	©	Alt+K	+
Alt+9	)	Alt+O	;	Alt+L	=
Alt+0	_	Alt+P	"	Alt+Z	:
Alt+M	.	Alt+N	,	Alt+B	*
Alt+C	?	Alt+V	/	Alt+X	£

Kempston Joystick (Numpad)

Numpad 8/2/4/6	Up/Down/Left/Right
Numpad 5 or 0	Fire (B button)
Numpad 7/9/1/3	Diagonals

Extended Kempston (Sega Genesis compatible)

Enable in Settings → Input → Extended. Uses port 0x1F bits 5-7:

[ (left bracket)	C button (bit 5)
] (right bracket)	A button (bit 6)
\ (backslash)	Start button (bit 7)

Hardware Gamepad

Enable in Settings → Input → Gamepad. Supports USB/Bluetooth controllers.

Calibration: Click "Calibrate" button to configure non-standard gamepads:

• Click "Assign" next to each direction/button
• Move stick or press button on your gamepad
• Mapping is auto-detected and saved

Up/Down/Left/Right	Directions (calibrate if needed)
Fire	Main fire button
C, A, Start	Extended buttons (Sega-style)

Mapping saved to browser localStorage and project files.

Kempston Mouse

Enable in Settings → Input → Kempston Mouse. Ports: FADF (buttons), FBDF (X), FFDF (Y).

Click screen or 🖱️ button	Capture mouse
Escape	Release mouse
Mouse wheel	Wheel (bits 7:4 of FADF, if enabled)

Debugger Hotkeys

F6 / Pause	Pause/Resume emulation
F7	Step Into (single instruction)
F8	Step Over (skip CALL/RST)
F4	Run to Cursor
F9	Toggle Breakpoint at PC
F11	Toggle Fullscreen
F2	Quicksave
F5	Quickload

Debugger

The built-in debugger provides comprehensive tools for development and reverse engineering.

Registers View

Shows all Z80 registers including the alternate set (AF', BC', DE', HL'). Flags are displayed as visual indicators: S, Z, H, P/V, N, C.

Configurable Panels

Left and right debug panels can show different views:

• Use the dropdown selector in each panel header to choose view type
• Left panel: Disasm or Memory
• Right panel: Memory, Disasm, or Calculator
• Step controls (Step Into, Step Over, etc.) appear in disasm panels
• Search controls appear in memory panels
• Bookmarks show panel type: 🔍 disasm, 📦 memory

Programmer Calculator

Available in the right panel dropdown. Features:

• Input in HEX, DEC, OCT, or BIN with simultaneous display of all bases
• 8/16/32-bit modes with signed/unsigned display
• Bitwise operations: AND, OR, XOR, NOT, shifts, rotates
• Expression evaluation: type formulas like "FF+10*2"
• Interactive bit grid for toggling individual bits
• History panel preserves calculations when switching views
• Base selector disabled during formula input to prevent conversion errors

Disassembly View

• Live disassembly from current PC with label support
• Click address to set "run to cursor" target
• Right-click for context menu (labels, regions, operand format, subroutines)
• Hover over addresses to see cross-references
• Subroutine separators (IDA-style) for marked routines
• Syntax coloring: registers, numbers, chars

Subroutines

• Right-click → "Mark as subroutine" to manually mark
• Auto-detected during Auto-Map Apply (CALL targets)
• Displays IDA-style separator before subroutine start
• Uses label name if available, or generates sub_XXXX

Code Folding

Collapse subroutines and custom blocks to reduce clutter in disassembly:

• Click ▾ toggle on subroutine header to collapse, ▸ to expand
• Collapsed view shows summary: "(N bytes, M instructions)"
• Right-click → "Create fold block..." for custom regions (data tables, init code)
• User fold markers displayed in magenta
• "Collapse all folds" / "Expand all folds" in context menu
• Auto-expands if PC enters a collapsed region
• Fold state saved in projects and localStorage

Operand Formatting

Right-click any disassembly line and select "Operand format..." to change how numeric operands are displayed:

• Hex: FFh, 1234h (default)
• Decimal: 255, 4660
• Binary: %11111111, %0001001000110100
• Char: 'A' (for printable ASCII)

Format settings persist per instruction address and are saved with projects.

Stack View

Shows current stack contents with return addresses highlighted.

Bookmarks

Quick navigation: click bookmark to jump, right-click to set bookmark at current address. 5 slots for disassembly, 5 for memory view.

Context Menu Navigation

Right-click any address in disassembly or memory view for quick navigation:

• Disasm left/right: Open address in left or right panel as disassembly
• Memory left/right: Open address in left or right panel as memory dump
• In memory view, right-click works on both hex bytes and address column

Labels

Labels provide meaningful names for memory addresses in the disassembly view.

Adding Labels

• Right-click address in disassembly → "Add Label"
• Or use the Labels panel "Add" button

Display Modes

• Address only: Show hex addresses
• Label only: Show label names
• Both: Show "address (label)"

Features

• Labels appear in operands: CALL main_loop
• Persistent storage per loaded file (localStorage)
• Import/Export to JSON files
• Click label in list to navigate

Breakpoints & Watchpoints

Execution Breakpoints

• Click gutter (left margin) in disassembly
• Or press F9 at current PC
• Execution pauses when PC reaches breakpoint

Conditional Breakpoints

Add conditions to break only when criteria are met:

Type	Examples
Registers	A==0, HL>4000, BC!=DE
Flags	Z, NZ, C, NC, P, M
Memory	(HL)==FF, (4000)==0, (IX+5)>10
T-states	T>=14335, TSTATES<20000
Operators	==, !=, <>, <, >, <=, >=, &, |
Literals	Hex: FF, 4000h / Decimal: 255

Watchpoints

Break on memory access:

• Read watchpoint: Break when address is read
• Write watchpoint: Break when address is written

Port Breakpoints

Break on I/O port access (IN/OUT instructions).

Memory Tools

Memory Dump

• Hex view with inline editing (click byte to edit)
• Click and drag to select range
• Right-click selection for region marking

Memory Diff

1. Click Snap to snapshot current memory
2. Run the program
3. Changed bytes are highlighted in the dump

POKE Search

Find memory locations storing game values (lives, score, etc.):

1. Snap - Take initial memory snapshot
2. Play game and change target value
3. Search with mode:
   • Decreased - value went down
   • Increased - value went up
   • Changed - any change
   • Unchanged - stayed same
   • Equals - specific hex value
4. Repeat to narrow candidates
5. Click result to view in memory dump

Graphics Viewer

View and analyze sprite/tile graphics stored in memory. Features a continuous memory dump view (EmuzWin-style). Access via the Graphics tab.

Memory Dump View

The main area shows memory rendered as graphics. Each byte is displayed as 8 horizontal pixels. A red rectangle marks the current sprite selection.

Controls

• Address: Current sprite address (hex). Press Enter to jump.
• Width: Sprite width in bytes (1-32). Each byte = 8 pixels. Max 32 = full screen width.
• Height: Sprite height in lines (1-64)
• Invert: Swap foreground/background colors
• Grid: Show grid lines (vertical between bytes, horizontal every 8 rows)
• x1/x2/x3: Zoom level for main dump view

Navigation

• -1/+1: Move sprite selection by 1 byte
• -Line/+Line: Move by one line (width bytes)
• -Row/+Row: Move by 8 lines (character row)
• -Spr/+Spr: Move by full sprite (width × height bytes)
• -Page/+Page: Move by 24 rows (192 lines × width bytes)
• Mouse wheel: Scroll the dump view

Actions

• Mark Region: Mark sprite as Graphics region (stores width/height)
• Copy Selection: Copy current selection as assembler DB statements
• Save Selection: Save current selection to .asm file
• Export All Marked: Export all marked Graphics regions to single file
• → Disasm: Jump to address in disassembly
• → Memory: Jump to address in memory dump

Memory Regions

Mark memory regions for reverse engineering analysis. Affects how memory is displayed in disassembly and memory map.

Region Types

Code	Executable code (default)
DB	Data bytes - shown as DB nn,nn,...
DW	Data words - shown as DW nnnn,...
Text	ASCII strings - shown as DB "text"
Graphics	Sprite/tile graphics
SMC	Self-modifying code

Auto-Map

Automatically detect regions during execution:

• Executed addresses marked as Code
• Read addresses marked as Data
• Code that gets overwritten marked as SMC

Memory Map Dialog

Visual 256x256 map of entire 64KB memory. Click to navigate, colors indicate region types.

Export ASM

Export disassembly as sjasmplus-compatible ASM file from the Memory Map dialog:

• Uses memory regions to determine code vs data
• Code regions disassembled as Z80 instructions
• DB/DW/Text regions exported with appropriate directives
• Graphics regions exported as DB with width/height metadata
• Includes labels and CPU state in header
• Addr+Bytes option adds address and hex bytes as comments
• Screen memory ($4000-$5AFF) exported as INCBIN directive

Cross-References (XRefs)

Track where addresses are referenced from in the code.

Generating XRefs

• Scan - Scan visible disassembly range
• Scan All - Scan full 64KB memory
• Runtime checkbox - Collect refs during execution

Viewing XRefs

Hover over an address operand in disassembly to see tooltip showing all references to that address.

Reference Types

• CALL - subroutine calls
• JP - absolute jumps
• JR/DJNZ - relative jumps
• LD - data references

File Formats

Snapshots (Load & Save)

Use the Save dropdown to choose format (SNA/Z80/SZX).

SNA	48K/128K - simple format, widely supported
SZX	Spectaculator format with zlib compression
Z80	v1/v2/v3 load, v3 save (48K/128K/+2/Pentagon)

Quicksave / Quickload

Instant state save/restore during gameplay using browser localStorage.

F2	Quicksave - saves current state
F5	Quickload - restores saved state

Also accessible via Save → Quick (F2) and Load → Quick (F5). Uses SZX format internally.

Tapes

TAP	Standard tape format
TZX	Extended tape format (turbo blocks, pure tone, loops)

Loading modes:

• Flash Load (default, checkbox on): Instant loading via ROM traps - most reliable
• Real-time (Flash Load off): Cycle-accurate playback with border stripes and sound

Note: Real-time tape loading is work in progress. Standard loaders and many turbo loaders work; some copy protection schemes may fail. Use Flash Load for problematic tapes.

Input Recording

RZX	Playback with embedded snapshot (may desync)

Disk Images

TRD	TR-DOS disk image (Pentagon/Beta Disk)
SCL	TR-DOS file archive (more compact format)
DSK	+3 disk image (standard and extended CPC DSK format)

Boot File Injection

Automatically add a boot loader to TRD disk images via Settings → Media → Boot File:

1. Click Select... to choose a boot file source (TRD or Hobeta)
2. Select the injection mode from the dropdown

No change	Load TRD images as-is (default)
Add boot	Add boot only if TRD has no boot file
Replace boot	Replace existing boot, or add if none

Supports TRD disk images and Hobeta files (typically .$b or .$c). When replacing, the new boot file reuses the old boot's disk location if it fits. Settings are saved in localStorage.

Archives

ZIP	Select file from archive dialog

Game Browser (Load → Web)

Search and download games online from Spectrum Computing (ZXDB database).

• Search by title - results sorted alphabetically
• View screenshots, year, publisher, genre, authors
• Direct download links for TAP, TZX, Z80, SNA files
• Drag downloaded files into emulator to play

Powered by ZXInfo API (api.zxinfo.dk). Zero dependencies - works directly from browser.

Project Files

Save/Load complete session state:

• Current snapshot
• All breakpoints and watchpoints
• Labels and comments
• Memory regions
• Cross-references
• Bookmarks
• Loaded media (TAP/TRD/SCL) with tape position

AY Music Export (PSG)

Record AY chip output to PSG file format in Settings → AY Capture:

• Record - Start capturing AY register writes
• Export - Stop and save as .psg file
• Cancel - Discard recording
• Changed only - Export only modified registers (smaller files)
• Get Player - Download Z80 assembly player source

The player source is sjasmplus-compatible. Use INCBIN "music.psg" to include your recorded music, then assemble to create a playable .sna file.

Screen Export

Capture frames in Settings → Export section:

ZIP	PNG sequence in ZIP archive
GIF	Animated GIF
SCR	ZX Spectrum screen (6912 bytes)
BSC	Screen + border (11136 bytes)
SCA	Animation format (see below)

SCA Animation Export:

• Type 0 - Full 6912-byte SCR frames (larger files)
• Type 1 - 8-byte fill pattern + 768-byte attributes per frame (multicolor)

Type 1 Fill Patterns:

Automatic	Detect pattern from screen bitmap
53c (AA 55)	Checkerboard dithering
127c (DD 77)	Ink-biased dithering
Vertical 4x8	4-pixel vertical stripes (F0)
Horizontal 8x4	4-row horizontal stripes (FF/00)
Custom	Enter 8 hex bytes manually

Type 1 is for multicolor animations where bitmap stays constant and only attributes change. Automatic mode detects if screen uses a consistent 8-byte pattern; prompts for choice if not detected.

Z80 Assembler

Integrated sjasmplus-compatible Z80 assembler for writing and testing code directly in the emulator.

Full sjasmplus Documentation

Keyboard Shortcuts

F9	Assemble code
Ctrl+F	Find
Ctrl+R or Ctrl+H	Find and Replace
F3	Find Next
Shift+F3	Find Previous
Escape	Close search bar

Toolbar Buttons

• Files ▼ - Browse project files (disabled when ≤1 file)
• Assemble - Compile the assembly code (F9)
• Inject - Write assembled bytes to emulator memory
• Debug - Inject code, set PC to entry point, switch to debugger. Entry point priority: SAVESNA address > single ORG > prompt if multiple ORGs
• Clear - Clear editor and reset project
• New - Add a new file to the project
• Load - Load .asm file or .zip project
• Export - Save source files as ZIP
• Download - Download generated output files (.bin, .sna, .tap). If multiple files, downloads as ZIP archive

Drag & Drop

• Drag .asm or .zip files directly onto the editor to load them
• If a file with the same name exists, you'll be asked to replace or add as new
• Drag ROM/snapshot files (.sna, .tap, .trd) onto the emulator screen area instead

Multi-File Projects

• Load a ZIP file containing multiple .asm files
• Main file (red label) is assembled first and includes others
• Click main file label to change which file is the main
• Use tabs to switch between open files
• Use INCLUDE "filename.asm" to include other files

Search All Files

• Open search bar with Ctrl+F
• Click All Files button to search across all project files
• Results show filename, line number, and matching text
• Click any result to jump to that file and line

Output Options

• Unused labels - Show labels that are defined but never referenced
• Show compiled - Include hex dump of assembled bytes

Command-Line Defines

Use the Defines input field to pass defines for conditional assembly:

• Format: NAME,NAME=value,...
• Simple define: DEBUG (value = 1)
• With value: VERSION=5 or BUILD=$100
• Multiple: DEBUG,VERSION=5,RELEASE

@define Markers

Add ; @define comments in the first 50 lines of your main file to show a dropdown of available defines:

; @define DEBUG
; @define RELEASE
; @define VERSION=5
; @define BUILD=$0100

The dropdown appears automatically. Ctrl+click to select multiple defines.

Output Files

Use directives to generate output files:

• SAVEBIN "file.bin", start, length - Save binary data
• SAVESNA "file.sna", start - Save 48K SNA snapshot
• SAVETAP "file.tap", CODE, "name", start, length - Save TAP file
• EMPTYTAP "file.tap" - Create empty TAP (for multiple blocks)

Generated files are listed in the output with size and MD5 hash.

MD5 Checksum Verification

Add expected MD5 hash in a comment to verify output:

SAVEBIN "game.bin", $8000, $1000  ; md5: a1b2c3d4e5f6...

Or use the MD5CHECK macro:

MD5CHECK "game.bin", "a1b2c3d4e5f6..."

Output shows MD5 OK or MD5 MISMATCH.

Supported Directives

• ORG - Set origin address
• EQU - Define constant
• DEFINE - Define symbol
• DB/DEFB - Define bytes
• DW/DEFW - Define words
• DS/DEFS/BLOCK - Reserve space
• DZ - Zero-terminated string
• DC - High-bit terminated string
• ALIGN - Align to boundary
• INCLUDE - Include source file
• INCBIN - Include binary file
• IF/ELSE/ENDIF - Conditional assembly
• IFDEF/IFNDEF - Check if defined
• MACRO/ENDM - Define macro
• REPT/ENDR - Repeat block
• STRUCT/ENDS - Define structure
• DEVICE - Set target device (ZXSPECTRUM48, ZXSPECTRUM128)
• SLOT/PAGE - Memory paging (128K)

Automated Tests

The Tests tab provides automated regression testing for the emulator using native Spectrum programs.

Test Configuration (tests.json)

Tests are defined in tests.json with the following structure:

{
    "tests": [
        {
            "id": "unique-id",
            "name": "Display Name",
            "file": "tests/program.tap",
            "machine": "48k",           // 48k, 128k, +2, +2a, +3, pentagon, pentagon1024, scorpion
            "earlyTimings": true,       // Use early ULA timings
            "ulaplus": false,           // Enable ULAplus (default: false)
            "palette": "default",       // Color palette
            "enabled": true,            // false to skip
            "fullBorder": true,         // Include border in comparison
            "diskRun": "game",          // TRD/SCL: program to RUN (optional)
            "author": "Author Name",    // Test program author
            "source": "https://...",    // Source URL
            "steps": [
                { "frames": 500, "screen": "tests/screen1.png" }
            ]
        }
    ]
}

Step Definition

Field	Description
frames	Absolute frame number from test start (required)
screen	Path to reference PNG screenshot (optional)
keys	Keys to press before running this step (optional)

Multi-Step Tests

For programs with multiple screens (e.g., menu → game → results), use multiple steps with key presses:

{
    "steps": [
        { "frames": 2350, "screen": "tests/menu.png" },
        { "frames": 5000, "screen": "tests/game.png", "keys": "ENTER" },
        { "frames": 8000, "screen": "tests/results.png", "keys": "SPACE" }
    ]
}

Note: Frame counts are absolute from test start, not relative to previous step.

Key String Format

Format	Example	Description
Single key	ENTER	Press Enter key
Letter/digit	a, 1	Press letter or digit
Caps Shift	CTRL+a	Caps Shift + A
Symbol Shift	ALT+p	Symbol Shift + P (produces ")
Sequence	ENTER,500ms,SPACE	ENTER, wait 500ms, then SPACE
Repeated keys	q,q,q,ENTER	Press Q three times, then ENTER
Repeated + delay	q,200ms,q,200ms,ENTER	Q, wait 200ms, Q, wait 200ms, ENTER
Comma key	ALT+n	Symbol Shift + N = comma on Spectrum

Special Keys

ENTER, SPACE, CTRL (Caps Shift), ALT (Symbol Shift), UP, DOWN, LEFT, RIGHT

Preview Mode

Use Preview to run a test with live display for calibrating frame numbers:

1. Select a test and click Preview
2. Click Pause when the desired screen appears
3. Click Copy Frame# to copy the frame count
4. Click Screenshot to save reference PNG
5. Update tests.json with the frame number and screenshot path

Example: Raxoft Z80 Test

{
    "id": "z80ccf",
    "name": "Raxoft z80ccf",
    "file": "tests/z80ccf.tap",
    "machine": "48k",
    "earlyTimings": true,
    "enabled": true,
    "steps": [
        { "frames": 2350, "screen": "tests/z80ccf_1.png" },
        { "frames": 5076, "screen": "tests/z80ccf_2.png", "keys": "ENTER" },
        { "frames": 6610, "screen": "tests/z80ccf_3.png", "keys": "ENTER" },
        { "frames": 8430, "screen": "tests/z80ccf_4.png", "keys": "ENTER" }
    ]
}

Example: TRD Disk Test

{
    "id": "disk-game",
    "name": "Game (TRD)",
    "file": "tests/game.trd",
    "machine": "pentagon",
    "diskRun": "game",          // Program name to run from disk
    "enabled": true,
    "steps": [
        { "frames": 500, "screen": "tests/game_menu.png" }
    ]
}

diskRun values: program name (e.g. "game") for RUN "game", or "boot" for RUN (boot file).

Example: DSK Disk Test (+3)

{
    "id": "plus3-game",
    "name": "Game (DSK)",
    "file": "tests/game.dsk",
    "machine": "+3",
    "enabled": true,
    "steps": [
        { "frames": 800, "screen": "tests/game_menu.png" }
    ]
}

DSK tests auto-boot via the +3 ROM. No diskRun needed — the +3 ROM auto-detects and loads from disk.

Compare Tool

The Compare tab allows comparing snapshots and binary files to identify differences in memory and CPU state.

Comparison Modes

Mode	Description
Snapshots	Compare two snapshot files (.SNA or .Z80, 48K or 128K)
Binaries	Compare two raw binary files byte-by-byte
Snapshot vs Emulator	Compare a snapshot file against current emulator state

Supported Formats

• Binary - Any raw binary file
• SNA - 48K (49179 bytes) and 128K (131103/147487 bytes)
• SZX - Spectaculator format (48K and 128K)
• Z80 - Version 1, 2, and 3 formats (48K and 128K)

Options

Option	Description
Show equal values	Display matching bytes in addition to differences
Hex dump	Show side-by-side hex dump with ASCII representation
Exclude screen	Skip screen memory ($4000-$5AFF and $C000-$DAFF for 128K)

Register Comparison

When comparing snapshots, CPU registers are displayed in two columns:

• Left column: Main registers (AF, BC, DE, HL, PC, IX, I, IM, Border)
• Right column: Alternate registers (AF', BC', DE', HL', SP, IY, R, IFF1, IFF2)

Differences are highlighted in red with a ◄ marker.

Memory Comparison

Memory differences are shown in a side-by-side hex dump with:

• Address and hex values for both files
• ASCII representation (unprintable chars shown as dots)
• Differing bytes highlighted in red
• Pagination for large differences (50 blocks per page)

Use Cases

• Verify emulator accuracy by comparing against reference snapshots
• Debug save state issues
• Analyze memory changes between two execution points
• Compare different versions of a program

Explorer

The Explorer tab analyzes ZX Spectrum file formats without loading them into the emulator.

Supported Formats

Format	Description
RZX	Input recordings
SCL	TR-DOS file archives
SNA	48K/128K snapshots with registers
SZX	Spectaculator snapshots
TAP	Tape files with block structure
TRD	TR-DOS disk images
Z80	Compressed snapshots (v1, v2, v3)
ZIP	Archives containing above formats

Sub-tabs

• File Info - File structure, blocks, registers, disk catalog
• BASIC - Decode and display BASIC programs with syntax highlighting
• Disasm - Z80 disassembly with ROM labels, click addresses in BASIC to jump
• Hex Dump - Raw hex view with ASCII column

Features

• Screen preview for snapshots and screen files
• Click on TRD/SCL files to view: BASIC files open decoder, CODE files open disassembly
• Click USR addresses in BASIC to jump to disassembly
• Disassembly shows blank lines after JP, JR, CALL, RET, RST, DJNZ, HALT
• Copy-friendly output format (text copies correctly to clipboard)
• ROM routine labels shown in disassembly

TR-DOS File Types

Ext	Type
B	BASIC program
C	Code (machine code)
D	Data array
#	Sequential file

JavaScript API

Access emulator via browser console:

// Access emulator
window.spectrum

// Get version
APP_VERSION

// Memory access
spectrum.peek(0x4000)
spectrum.poke(0x4000, 0xff)

// Control
spectrum.start()
spectrum.stop()
spectrum.reset()

// Breakpoints
spectrum.addBreakpoint(0x0000)
spectrum.addBreakpointWithCondition('4000', 'A==0')
spectrum.removeBreakpoint(0x0000)
spectrum.getBreakpoints()
spectrum.clearBreakpoints()

// Labels
labelManager.add({
    address: 0x4000,
    name: 'main_loop',
    comment: 'Main game loop'
})
labelManager.get(0x4000)
labelManager.remove(0x4000)
labelManager.findByName('main_loop')
labelManager.exportJSON()
labelManager.importJSON(jsonStr, merge)

The Name

ZX-M8XXX stands for ZX Matrix — a nod to the iconic 8-bit architecture and the intricate web of code, memory, and pixels that make up the Spectrum experience.

License

This software is released under the GPL-3.0 license.

You are free to use, modify, and distribute this software under the terms of the GNU General Public License version 3.

Read the full GPL-3.0 license text

Test Programs: The test programs in the tests/ folder (z80ccf, z80doc, z80docflags, etc.) are copyright of their respective authors. These programs are included for emulator validation purposes only.

Source Code

https://github.com/Bedazzle/ZX-M8XXX

Inspired By

• JSSpeccy 3 - Matt Westcott's excellent JavaScript Spectrum emulator
• Fuse - The Free Unix Spectrum Emulator
• EmuzWin - Windows Spectrum emulator
• Swan - Delphi Spectrum emulator (I/O contention algorithm)
• ZXMAK2 - .NET Spectrum emulator
• IDA Pro - Interactive disassembler (debugger UI concepts)
• Ghidra - NSA reverse engineering tool (analysis features)

Known Limitations

• Chained prefix interrupts: On real Z80, interrupts can occur between chained DD/FD prefix bytes (each prefix is a separate instruction fetch). This emulator processes prefix chains atomically within a single step, so interrupts cannot occur mid-chain. This rarely affects real software.
• Floating bus: Not fully emulated. Some copy protection schemes may not work.
• Z80 save uncompressed: Z80 snapshots saved without RLE compression for compatibility (~131KB for 128K, ~49KB for 48K).

Technical References

• Z80 CPU User Manual (Zilog)
• The Undocumented Z80 Documented (Sean Young)
• World of Spectrum documentation

Greetings

Greetings fly out to:

• The ZX Spectrum demo scene and retro computing community
• All the developers keeping the Speccy spirit alive
• Everyone who contributed to documenting the Z80 and ZX Spectrum hardware
• Amstrad for allowing free distribution of Spectrum ROMs

"The Spectrum lives on!"