A developer's emulator for the ZX Spectrum Next

JNEXT is a real-time software emulator of the ZX Spectrum Next computer, written in C++17. It uses the official ZX Next FPGA core VHDL sources as the authoritative hardware reference. The main goal is to have a good enough emulator to allow comfortable game development for the Next, and a good debugger with lots of introspection features.

Specifically, extremely faithful emulation of the ZX Next is not the main goal of this emulator. But indeed having the VHDL sources available makes it easier to know the expected behaviour.

Current Status: ALPHA — features still being actively developed. Issues and pull requests will be welcome once the repo is in a somewhat stable state. For now, I recommend to just wait until a mostly working emulator is published.

See the JNEXT full development plan for the real status of the project, the features that have already been implemented, upcoming features and others that are further in the roadmap.

Current status of the screenshot-based regression tests: CURRENT-REGRESSION-STATE

JNEXT was fully developed by Claude (Anthropic's AI), with human guidance and supervision. The complete prompt history, design documents, daily task files, and development documentation are available in the repository. This makes JNEXT not just an emulator, but also a practical case study in developing a large, complex piece of software using AI-assisted programming.

JNEXT emulates the full ZX Spectrum Next hardware feature set: Z80N CPU, ULA (48K + Timex modes), Layer 2, hardware sprites, tilemap, Copper, layer compositor, AY-3-8910 × 3 (TurboSound), DAC, Beeper, DMA, DivMMC, UART, CTC, SPI / I2C / RTC, IM1/IM2 interrupts, joystick, and keyboard.

For the authoritative, always-current inventory of what is implemented, what has known gaps, and what is out of scope, see:

• Known functionality gaps and proposed plan — every subsystem-level gap, sorted by display-impact priority, with affected subsystems, user-visible impact, and effort estimate.
• Subsystem unit-test status — live per-subsystem dashboard (Pass / Fail / Skip rows) reflecting exactly what is verified against the ZX Next FPGA VHDL as oracle.

• File loading — NEX, SNA, SZX, TAP, TZX, WAV via File menu or toolbar
• Machine type selection — 48K, 128K, +3, Next
• CPU speed control — 0.5×, 1×, 2×, 4×, or custom percentage
• Tape controls — Open, eject, rewind; fast load or real-time playback
• SD card mounting — Mount .img disk images for DivMMC
• PNG screenshot — File > Save Screenshot or Ctrl+S
• Video recording — Record to MP4 via FFmpeg (File > Start/Stop Recording)
• RZX playback and recording — File menu
• CRT scanline filter — View menu toggle
• Fullscreen — True fullscreen with letterbox aspect ratio (F11)
• Scalable display — 2×, 3×, 4× integer scaling, Hi-DPI pixel-perfect rendering
• Status bar — FPS, CPU speed, machine type, tape status, rewind state

The integrated debugger opens in a separate window and provides full introspection into the running emulator:

• CPU registers — All Z80/Z80N registers, flags (S/Z/H/P/V/N/C), halt, interrupt mode, ULA active screen
• MMU panel — Next 8-slot MMU table with page numbers and type; 128K bank mappings
• Disassembly — Scrollable Z80+Z80N disassembly, PC highlighting, breakpoint gutter, follow-PC mode, run-to-cursor, symbol names from MAP files
• Memory hex editor — Full 64K view, hex+ASCII, inline editing, page/bank selector
• Stack panel — SP-relative word view, SP row highlighted
• Call stack — CALL/RST/INT/RET tracking with symbol resolution
• Breakpoints — Execution, read, write, and I/O watchpoints; unified panel view
• Watch expressions — Byte, word, or long at arbitrary addresses with custom labels
• Video subpanels — ULA (primary+shadow), Layer 2 (active+shadow), Sprites, Tilemap; per-scanline view up to current raster position; checkerboard for transparent pixels
• Sprite viewer — All 128 hardware sprites with full attribute table
• Copper disassembly — Decoded WAIT/MOVE instructions with current PC indicator
• NextREG panel — All 256 registers with names, hex values, editable inline
• Audio panel — AY register state for all 3 TurboSound chips, per-source mute controls
• Trace log — Circular instruction trace buffer, export to file
• Symbol table — Load Z88DK MAP files; symbols shown inline in disassembly and watches
• Backwards execution (rewind) — Frame snapshot ring buffer; Step Back, Frame Back, rewind slider; configurable buffer size

Debugger keyboard shortcuts:

• Magic breakpoint — ED FF (ZEsarUX) or DD 01 (CSpect) opcodes trigger debugger pause when enabled; act as NOP otherwise. Enable via --magic-breakpoint or Debug menu.
• Magic debug port — Writes to a configurable port are logged to stderr in hex, decimal, ASCII, or line-buffered mode. Enable via --magic-port PORT --magic-port-mode MODE.

./build/gui-release/jnext [options]

Fedora / RHEL:

sudo dnf install SDL2-devel cmake gcc-c++ qt6-qtbase-devel libpng-devel zlib-devel

Debian / Ubuntu:

sudo apt install libsdl2-dev cmake g++ qt6-base-dev libpng-dev zlib1g-dev

Windows and macOS builds are pending.

git clone --recursive https://github.com/jorgegv/jnext.git
cd jnext

# Full Qt6 GUI build (recommended)
make gui-release

# SDL-only build (no GUI, no debugger)
make release

Executables are placed in build/gui-release/jnext and build/release/jnext respectively.

Wave 0.3 (2026-05-04) made the user-supplied SD-card image the canonical source for every ROM jnext needs at runtime, mirroring real ZX Spectrum Next hardware:

• FPGA boot ROM (nextboot.rom, 8 KB) is silicon-baked: embedded into the jnext binary at link time. No flag, no SD lookup.
• All other ROMs (DivMMC, NextZXOS, 48K/128K/+3 BASIC, Multiface) are read from the --sd-card image at canonical TBBlue paths (/MACHINES/NEXT/...).

The TBBlue distribution image is the standard reference: see CLAUDE.md for the canonical fixture path (roms/nextzxos-1gb-fat32fix.img).

--sd-card FILE is required for every invocation (jnext is a ZX Spectrum Next emulator and the SD image is the canonical source for all peripheral and machine ROMs — same as real hardware).

# Boot NextZXOS / TBBlue firmware (default Next machine)
./build/gui-release/jnext --sd-card roms/nextzxos-1gb-fat32fix.img

# Run as ZX Spectrum 48K (uses /MACHINES/NEXT/48.rom from SD)
./build/gui-release/jnext --machine 48k --sd-card roms/nextzxos-1gb-fat32fix.img

# Load and run a NEX file (boot-ROM overlay skipped automatically)
./build/gui-release/jnext --load game.nex --sd-card roms/nextzxos-1gb-fat32fix.img

# Load a TAP file (will auto-type LOAD "")
./build/gui-release/jnext --load game.tap --sd-card roms/nextzxos-1gb-fat32fix.img

# Load a snapshot
./build/gui-release/jnext --load game.sna --sd-card roms/nextzxos-1gb-fat32fix.img

# Run at double speed
./build/gui-release/jnext --speed 200 --sd-card roms/nextzxos-1gb-fat32fix.img

# Inject a raw binary at address 0x8000 and run
./build/gui-release/jnext --inject program.bin --inject-org 8000 \
    --sd-card roms/nextzxos-1gb-fat32fix.img

# Headless screenshot for CI testing
./build/gui-release/jnext --headless --machine 48k \
    --sd-card roms/nextzxos-1gb-fat32fix.img \
    --delayed-screenshot /tmp/test.png \
    --delayed-screenshot-time 3 --delayed-automatic-exit 5

A full regression test suite runs the FUSE Z80 opcode tests (1356/1356 pass, 100%) and screenshot comparison tests in headless mode:

make regression

• ZX Spectrum Next FPGA core — The official VHDL sources serve as the authoritative hardware specification for this emulator.
• TBBlue Firmware sources — The official firmware sources are useful for problem tracing and debugging.
• FUSE — The Z80 CPU core is adapted from FUSE. ROM files are loaded from the FUSE package installation.
• ZesarUX — Multiple Sinclair system emulator with Next support, used as a behavioural reference during development.
• CSpect — Another ZX Emulator with Next support, also used as a behavioural reference during development.
• ZX Next Wiki - The official reference point for Next development.

Copyright (C) 2026 Jorge Gonzalez Villalonga

JNEXT is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version.

JNEXT is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the LICENSE file for the full license text.