#zenzx — Public Fediverse posts

The last few days of ZenZX and zen80 development (my ZX Spectrum emulator and my Z80 emulator respectively) have been mostly about fine tuning memory contention correctness with precise T-state count, I/O contention, floating bus emulation, ULA last out byte, and a few other quirks and idiosyncracies very particular to ZX Spectrum emulation.

I'm not aiming to make ZenZX a simulator (like flooh's Z80) or an extremely precise emulator (like @FromTheFourthPlanet 's SpecIDE).

The first goal of ZenZX is to be a legible and usable ZX Spectrum emulator written in Go. That has already been largely achieved.

The second goal is subjective: to be able to run a good part of the software I personally considered to be some of the best I used to know for the ZX Spectrum back in the day. This has been largely achieved as well. My shortlist was that an emulator that is able to run Batman, Head Over Heels, Bruce Lee, and Jet Set Willy is a good enough ZX Spectrum emulator. Of course there is plenty of room for disagreement about the specifics here, but the general idea was that if some of the best titles are able to run on ZenZX, why wouldn't most others worth playing?

Which takes me to the third criteria: running a game is not exactly the same as loading it, and having dedicated quite a lot of effort to emulate the NEC FDC controller of the Spectrum +3, for a whille I neglected tape loading. The reason for that was that I had already developed reasonably functional loaders of .Z80 and .SNA snapshots, as well as ZenZX's own richer snapshot format .ZXS.

Though not the main focus of ZenZX, tape loading is historically important and there are many tape files of copy-protected games that ZenZX is still unable to load, even if it's able to run the games they contained via snapshot files. The other reason this has taken a long time is that loading of copy-protected tapes for some kinds of turbo loaders implies clock-perfect emulation, and perfect simulation of a host of ULA and bus peculiarities. Perfection of simulation of all the quirks has never been a ZenZX goal, but still, considering the historical weight of tape loading I persevered.

But there is a limit to how much perfection I can achieve within the technical limits and scope of ZenZX. Within the range of stated goals for ZenZX, in the next few weeks I'll be nearing the end of the correctness checks I aimed to deliver, most games run, many more tapes now load which didn't load before the latest improvements, but the truth remains that many copy-protected tape files were never part of the goal, still don't load and may never load.

What still lies ahead is massive UI improvements, making it more usable, making it more enjoyable, supporting a few more Speccy cousin models and custom ROMs, and possibly providing support for esxDOS. In that direction, both the Zenas assembler, and the zen80 emulator are now compatible with the ZX Spectrum Next's Z80N, including a test harness that checks behaviour against CSpect.

My expectation is that ZenZx is going to reach version 1.0 sometime in the next few weeks or months, delivering a reasonable emulation of ZX Spectrum 48k and ZX Spectrum 128k models, along with a list of tested titles that actually run on it.

Updates and fixes and new releases of the 1.x branch will continue for the reminder of 2026. The rest of the stuff that doesn't make it to the 1.x cycle is going to be scheduled to be released as part of a roadmap towards 2.0, sometime in 2027.

References:
-- flooh's cycle-stepped Z80 simulator
https://floooh.github.io/2021/12/17/cycle-stepped-z80.html

-- Martian Girl's SpecIDE ZX Spectrum emulator
https://github.com/MartianGirl/SpecIde

#zenzx #zen80 #Spectrum #ZXSpectrum #Speccy #emulator #foss #golang

Progress is being made. Complete success is still probably days or weeks away.

#zenzx #emulator #golang #foss #ZXSpectrum #Speccy #Spectrum #retrogaming #retrocomputing

Due to the way the zen80 emulator works (the Z80 emulator I wrote) and because when I started it I aimed for readability of the code and educational value more than raw performance, I've been hitting against a few limitations that seemed somewhat intractable when trying to make ZenZX load fast a good portion of the ZX Spectrum game titles that use a "turbo" copy protection.

For many titles that don't use that specific type of copy protection, ZenZX could load .tap and .tzx files just fine in "fast" mode, instantly loading and playing a game that used to take 3 or 4 minutes to load from tape. But games like Chase H.Q. and others, especially those which have substantial 128k versions, were a different story.

The design of zen80 (and ZenZX by extension) doesn't easily allow for dynamic acceleration of the virtual Spectrum's memory access beyond a certain limit. This would have been trivial to solve in C or C++ using a union structure to access memory through different field arrangements, but Go (the language I chose to write zen80 and ZenZX) doesn't admit union structures. (and I could have used Go's unsafe package to implement something equivalent, but that would have defeated the educational purpose of writing an emulator in safe, readable, and educationally useful Go).

So I was faced with the difficult possibilty of having to substantially redesign the emulator I've been working on for a couple of years.

Thankfully, that wasn't necessary. I designed an alternative "fast-track" memory that zen80 can use to read from and write to memory and i/o ports, which represents an addition and extension to the existing design, whilst keeping all the existing interfaces the same.

What good is it to have these extensions if, essentially, the CPU that already exists, and the one that's already wired into the code can't be dynamically accelerated to the maximum? you might ask.

Well, what it does is that it allows me to execute a second Z80 in parallel, just for the turbo loaders, with very high precision, at very high speed. The maximum speed a modern computer can achieve is potentially thousands of times the speed of an emulated Z80, especially for a Z80 that's running in parallel without need to update the screen.

So essentially, ZenZX now has a third tape loading mode --tapemode=turbo, in addition to the already existing --tapemode=fast and --tapemode=accurate, with "accurate" being an euphemism for f* slow, identical to the original ZX Spectrum ROM tape loading routine.

After some minor surgery to the code, a parallel Z80 instance now loads the game in a separate, faster memory, and when it's done loading and decoding whatever it has to do in turbo mode, every new tape block is copied verbatim to the memory of the user-facing emulator that ZenZX is running on the front shop.

I don't have much evidence to show yet, as I'm ironing out a number of other new wrinkles, trying to deliver a more polished user interface than you have seen in the last week or so. The thing with screenshots when everything goes right is that they look exactly the same as when everything went wrong but you fixed the problem 🤣

Here they are, for now you have to take my promise that these games actually loaded very fast! 🤣

#ZXSpectrum #Spectrum #Speccy #retrogaming #retrocomputing #zenzx #emulator #golang #foss #z80

Zenscript is not really a grown-ass language, it's more like a declarative file format inspired by subtitle files, with time-addressed steps expressed in frames, which allows you to perform certain basic scripted functions in the ZenZX emulator.

For example wait until the machine boots up, then load a binary in memory, then press a key, leave it pressed for the duration of 10 frames, look what a variable holds, and once that variable reaches an expected value, take a screenshot.

I'm adding to ZenZX the ability to grab a file with symbols from Zenas or Pasmo (.sym). So that's the new thing that the script in the screenshot can do, load symbols, refer to variables, and trigger conditions. The two new keywords are: wait-mem and expect-mem.

Of course maybe you can do some of the same playing it manually, and using a good debugger. (or in the case of @stevewetherill , watching the screen border flash 🤣 ) but this is better when you need to run automated tests hundreds or thousands of times.

This is between me and you, but I enjoy doing this a thousand times more than playing any games.

#zenzx #emulator #z80 #ZXSpectrum #Spectrum #Speccy #retrogaming #retrocomputing #golang #foss

I didn't get much sleep, but I got lots of bits! And now it's time for a good nap.

#ZenZX #ZXSpectrum #Speccy #Spectrum #emulator #golang #foss #retrocomputing

Probando las ROMs oficiales en Español. A continuación voy a estar agregando otras ROMs no oficiales para varios otros idiomas.

Testing the official Spanish ROMs. Up next, I'll be adding extra unofficial ROMs for various other languages.

In a second pass, unofficial ROMs will go under the "Custom ROMs" menu, so the mechanics will be: start any supported machine you like, then replace the ROMs as desired.

Third pass: compose your own Spectrum from the set of hardware features implemented, and call that a new "Machine".

#zenzx #emulator #foss #golang #ZXSpectrum #Spectrum #speccy

So far so good.

#zenzx #ZXSpectrum #Spectrum #Speccy #golang #foss #retrocomputing #emulator

The ZenZX emulator used to have not even a semblance of user interface beyond what the ZX Spectrum itself displays. I'm now bringing into ZenZX the vaguely Spectrum-inspired GUI toolkit I had created for Zenimate. With a little luck I'll be making it easier to use for human beings.

#ZenZX #ZXSpectrum #Spectrum #Speccy #retrocomputing #golang #foss

This is starting to look more polished.

#zenzx #emulator #ZXSpectrum #Speccy #Spectrum #retrocomputing #TS2068 #golang #foss

I've been doing a little cartography work for the ZenZX emulator, mapping out what compatibility features exactly are yet to be delivered.

#zenzx #Spectrum #ZXSpectrum #Speccy #retrocomputing #emulator #golang #foss

ZenZX is getting Timex Sinclair 2068 emulation. Just because.

This may not look like much but it's the output of a small programme plotting on the screen in so-called HiColour mode.

Also adding Kempston and Sinclair joystick emulation, plus Kempston and AMX mouse emulation.

A Timex Sinclair 2068 is like a Spectrum with extra graphics, and the same AY sound chip that was later inherited by the ZX Spectrum 128k, plus Kempston joystick ports, and some fancy memory modes.

#zenzx #ZXSpectrum #TS2068 #TC2048 #Spectrum #Speccy #

I was finally able to correct my emulator, ZenZX, to make it work with ZX Spectrum +3 floppy discs which weren't so floppy. With many thanks to @FromTheFourthPlanet for her wonderful emulator, SpecIde, I learned massively from her generous gift and her deep knowledge of the machinery involved.
https://github.com/MartianGirl/SpecIde

Now I'm able to load The Artist II by Ocean Software from a DSK image. I wasn't able to draw f** s** using its keyboard layout. Here's a dodgy invader for you.

#pixelart #theartist #ZXSpectrum #Spectrum #Speccy #retrocomputing #zenzx

With Zen80 guaranteed to run on Linux, the next logical step was to try out ZenZX and play some ZX Spectrum stuff. After a little fiddling with GL and Alsa libraries, it compiled right away and ran. Quite smoothly to my surprise!

#zen80 #zenzx #ZXSpectrum #spectrum #speccy #retrocomputing

Debugging my macros. The good thing is that after you have some well designed macros, most of the simple text user interface things behave almost like BASIC, or terminal printing in Pascal.

Also a good chance to dog food myself using the barely improved editor, and trying to make the zenas assembler work and assemble my non-trivial Z80-based text editor. Dog food is good food!
The only problem I found today was a regression in the vim-like command to jump to a line number. One other thing I noticed is that horizontal scroll doesn't work reliably when you have very long lines that extend beyond the right margin.

That being said, It's a little miracle I have never seen it crash, not a single time, during actual development work.
The best of news is that there are not many news on that front!

#bim #tbim #zenas #z80 #zen80 #zenzx #retrocomputing #ZXSpectrum #speccy #Spectrum

tbim, bim, zenas, zen80

Yes, of course all of these things can be done mixing and matching disparate tools in some other ways, but as a matter of access and code legibility you will be able to directly examine every single bit of the toolset and toolchain.

Every single bit traceable, nowhere left for bits to hide. That's something you can't do unless you're a highly sophisticated specialist today.

#bim #tbim #zenas #zen80 #zenzx #retrocomputing #golang #foss

zenas, zen80, bim and assorted tools

Things starting to fall into place like Tetris bricks!

I still can't glue the ZenZX emulator to the text mode editor, but when I decouple the text mode renderer from the editor logic (sometime next year), I should be able to render the editor and other tools using Deluxe UI in a GL-accelerated window, and I should be able to embed ZenZX in a bim pane.

But essentially everything you see in this screenshot, from tiling manager, to editor, to assembler, to emulator, is one single coherent and consistent codebase (with the sole exception of the Spectrum ROM!)

Lots of work ahead in 2026!

Longer term project beyond 2026 will be to get the language ual off the ground and port all these things to ual.

#bim #tbim #zenzx #zen80 #zenas #foss #golang #retrocomputing #z80

bim editor

I've just barely improved the barely improved editor to support Z80 assembler syntax. The automatic detector of assembly dialect doesn't always work right though, that's a task pending in the backlog.

Up next: running zen80 inside the editor.

#z80 #golang #foss #retrocomputing #bim #zen80 #zenzx

I found another bug in ZenZX's 128k mode with snapshot saving. Wonderful Dizzy loads, runs, plays great. Then I save a snapshot. Snapshot is saved correctly. Reset. Then load that snapshot, the snapshot loads and resumes execution exactly where it left, no crashes, everything works except for keyboard input. Which seems to be something possibly related to interrupt handling, it's possible that I am somehow leaving interrupts disabled after resuming the snapshot. Time to debug some more.

#ZXSpectrum #Spectrum #Speccy #zenzx #emulator

So Wonderful Dizzy (a game for the ZX Spectrum 128k models) is running quite well in 128k mode on ZenZX. One caveat is that thae fast tape loading feature didn't work this time, more debugging is needed. I'm also going to have to compare the quality of music playback taking other emulators as parameters of reference. All in all, a more successful test than I anticipated.

#ZXSpectrum #Speccy #Spectrum #spectrum128 #Spectrum128k #ZXSpectrum128 #ZXSpectrum128k
#zenzx #emulator #golang #foss #zen80 #z80 #retrocomputing #retrogaming

Wonderful Dizzy on ZenZX, requires 128k mode.

The Oliver Twins 2020
https://zxart.ee/eng/software/games/adventure/kvesty-golovolomki/wonderful-dizzy/dizzy-viii---wonderful-dizzy-2020-v15/

#ZXSpectrum #Speccy #Spectrum #retrogaming #retrocomputing #zenzx

The emulator ZenZX has been up past one hour running a modern Speccy game continuously without memory leaks or crashes.

Go, BubbleBack, go!

#ZenZX #zen80 #z80 #Spectrum #Speccy #ZXSpectrum #emulator #retrogaming #retrocomputing

I may have taken certain artistic liberties.

#zenzx #zen80 #ZXSpectrum #Spectrum #Speccy #retrocomputing

Maybe the visuals won't improve .tap support by much. But... why not?

#zenzx #zen80 #ZXSpectrum #Spectrum #Speccy #retrocomputing

Work in progress.

#zenzx #emulator #golang #foss #ZXSpectrum #Spectrum #Speccy #retrocomputing

Further experiments on the virtual keyboard front.

No idea where this is going really, very experimental.

#zenzx #emulator #golang #foss #ZXSpectrum #Spectrum #Speccy #retrocomputing

Further experiments on the virtual keyboard front (2/2)

(and possibly using the often unused border space for some useful things, a bit like FUSE does with some indicators)

#zenzx #ZXSpectrum #Spectrum #speccy #retrocomputing

·

Further experiments on the virtual keyboard front. (1/2)

#zenzx #ZXSpectrum #Spectrum #speccy #retrocomputing

So... I've had this under wraps for months, whilst I've been adding features and ironing out bugs...

I've already been showing:

• zen80: zexall-tested z80 emulator
  https://github.com/ha1tch/zen80

• zenZX: ZX Spectrum emulator (WIP)
  https://oldbytes.space/@haitchfive/115159221509967137

The next logical piece is:

• zenas: Z80 assembler (WIP)

zenas is a new Z80 assembler (work in progress) following a simpler design than my earlier attempt. This is designed to work together with zen80 and zenZX, to hot test and benchmark the code the assembler emits

I'm already seeing some promising results. I think it's a cool feature if your assembler can actually run the code it emits (using zen80) with the potential to verify your object code actually works, and every single cycle is accounted for. I can imagine in the future we can expect to have things like register colouring and other neat features.

If we consider the zenXX tools together with the tape handling tools, and with the floppy image tools, we're approaching the status of lovely toolset that could one day be quite useful.

#zen80 #zenzx #zenas #asm #z80 #golang #foss #assembler #retrocomputing

ZenZX tape loading

(3/3)

#ZXSpectrum #Spectrum #Speccy #retrocomputing
#retrogaming #zen80 #zenzx
#emulator #golang #foss

ZenZX tape loading

PageUp: Zoom In
(Increments zoom factor)

PageDown: Zoom Out
(decrements zoom factor)

Alt+B / Option+B: toggles visibility of the Spectrum "border"

(2/3)

#ZXSpectrum #Spectrum #Speccy #retrocomputing
#retrogaming #zen80 #zenzx
#emulator #golang #foss