Besides SpectNetIDE, I'm actively working on bringing a similar experience to Visual Studio Code with Klive IDE. In the future, though I still maintain this project, I focus on Klive IDE.

I have been actively working on version 2 since June 2019.

• Totally rewitten Visual Studio integration. I removed many annoying issues related to solution loading.
• Multiple ZX Spectrum projects. You can put more than one ZX Spectrum project into a single solution. While working, you can change the active project anytime.
• Boriel's BASIC (ZX BASIC) integration. Besides Z80 assembly, now, you can use ZX BASIC as your programming language to create spectacular games and applications.
• New debugging tools. The ZX Spectrum emulator provides two extra options: ULA render point indication, and shadow screen rendering.
• New, more modern project item icons.

Preview 9 has these limitations:

• ZX BASIC source code debugging is not supported yet.

I decided not to implement VS 2017 compatibility, so version 2.x will work only on Visual Studio 2019, or later. Also, I discontinue implementing the Z80 Assembler Output and Z80 Unit Test Explorer, and Spectrum Scripting Console App features, as they are not used by the community.

You can download the v2.0-preview 9 VSIX installer file here.

Stay tuned!

This project implements a ZX Spectrum integrated development environment (IDE) that is integrated into Visual Studio 2017 and 2019. Initially, I intended this project to be just a demo project so that I can use it in my agile software design and testing courses. However, it became a fun project.

It (will) support the following ZX Spectrum models:

• ZX Spectrum 48K — Emulator and tooling completed
• ZX Spectrum 128K — Emulator and tooling completed
• ZX Spectrum +3E — Emulator and tooling completed
• ZX Spectrum Next — Emulator and tooling development is in progress

At the moment the code is entirely written in C#. Nonetheless, I plan to implement certain parts in C++ (somewhen in the future, for the sake of performance), and maybe in JavaScript/TypeScript, too.

SpectNetIde supports you in two main scenarios:

1. Code discovery. The IDE is full with tools you can use to discover/reenginer exsisting BASIC/Z80 assmebly code.
2. Code creation. You can easily create, run, debug, and export Z80 assembly code.

I cannot be grateful enough to Simon Brattel. Many features I have been implementing in the SpectNetIde assembler were inspired by Simon's outstanding Zeus Z80 Assembler. I honor his ideas and work.

You can download the VSIX installer file here.

To get an impression about SpectNetIde, see these short articles with screenshots:

1. Install SpectNetIDE
2. Create your first ZX Spectrum project
3. Use the Keyboard Tool
4. Create and run a simple BASIC program
5. Create and run a simple Z80 program
6. Export a Z80 program
7. LOAD a program
8. Fast (Instant) LOAD
9. The ZX Spectrum Emulator

Probably is less mature than most of the ZX Spectrum emulators with longer past — Nevertheless, this project has some unique features:

• Unit tests for Z80 code. The Z80 test language allows you to define and run unit tests for your Z80 code.

• Requires no configuration. You start the IDE, create a ZX Spectrum project, and everything is ready to work.

• The code is well commented and harnessed with unit tests. I plan to add a lot of documentation that helps you understand how to design and develop such an emulator. I also plan articles about Visual Studio 2017 extensibility.

• Great development tools. The project adds many useful features integrated into the VS 2017 IDE that you can develop for understanding ZX Spectrum applications and games, discover their code, and develop new ZX Spectrum apps.

• ZX Spectrum Emulator tool window in the IDE

• ZX Spectrum project type to keep together everything you use to create and debug your Z80 assembly apps.

  • Disassembly tool. The ROM comes with annotations (labels, comments, symbols, memory maps) that you can use while examining the code. The disassembler recognizes Spectrum-specific byte codes, such as the ones used by the RST #08 and RST #28 instructions.
  • Registers with ULA counters. You can follow not only the Z80 registers, but the most important information about the ULA.
  • Tape Explorer to examine .TZX and .TAP files. You can peek into the BASIC programs they contain, or disassembly the code in the tape files.
  • BASIC List view to display the BASIC program list loaded into the memory
  • Debugging the code with breakpoints, Run/Pause/Step-Into/Step-Over/Step-Out commands
  • Watch Memory view with powerful watch expressions to examine CPU and memory state while debugging.
  • Stack view tool. Besides the stack contents, you can see — with disassembly — the instructions that placed a particular value to the stack.
  • Spectrum VM state management. You can save and load the current state of the Spectrum virtual machine to a file, or even add it to the project hierarchy. When you start a Z80 program, the IDE uses VM states for fast code load and execution.
  • Virtual floppy disk support. You can create virtual floppy disks for the Spectrum +3e model, insert them into the virtual floppy drives, eject them, make the floppies write protected, or remove the write protection.

• Full-blown Z80 assembly programming. The SpectNetIde Assembler provides you a robust Z80 assembler and related toolset.

  • Syntax-highlighted editor
  • Convenient syntax (for example, labels are accepted with or without a subsequent colon; alternative syntax variations, for example, both jp (hl) and jp hl are accepted, as well as sub b and sub a,b)
  • String escape sequences for ZX Spectrum-specific characters. The assembly language supports escapes for control characters like AT, TAB, PAPER, £, or ©.
  • Loops and conditional statements
  • Powerful dynamic macros
  • Source code debugging. You can set up breakpoint in the source code. When they are reached, the corresponding source code is displayed. Run/Pause/Step-Into/Step/Over commands are available with source code, too.
  • Z80 Program code export. You can export the Z80 assembly code into .TZX and .TAP code files that can be immediately LOADed into ZX Spectrum — with optional auto start support.

• Scripting object model. You can create scripts to automate common task with the scripting object model.

I do not want to stop here, and plan a number of exciting features:

• More emulators with development tools: ZX Spectrum +3, ZX Spectrum Next
• Compiler for a higher level language
• Integrated development tools for ZX Spectrum Next features (for example sprites with editors, etc).

You can contribute to the project. Please contact me by email: dotneteer@hotmail.com