#z80 — Public Fediverse posts

The next few issues of FREEZE64 and FREEZE-ZX ‘zine to come out of FREEZE Towers.
Busy, busy 😃👍
https://freeze64.com
https://freeze64.com/freeze-zx/
#Commodore64 #C64 #Commodore64Ultimate
#ZXSpectrum #Speccy #Z80
#RetroGaming #RetroGames
#IndieGames #GameDev

This week on the blog: ...mostly showing my work for what fed into last week's post, actually. A line-by-line comparison of four implementations of the same function on four variously related retro architectures.

This is gonna be one of the crunchy ones that most folks will want to skip but that the folks who like it will *really* like, in my experience.

https://bumbershootsoft.wordpress.com/2026/05/09/comparing-an-lz4-decompressor-on-four-legacy-cpus/

#retrocomputing #z80 #6502assembly #8086assembly #intel8080

Yesterday I had the great pleasure to attend a documentary screening and panel session where Prof. #FredericoFaggin was the guest of honour. This was organised by the #Italian Luxembourg Chamber of Commmerce and introduced by the Italian Ambassador to #Luxembourg. #Faggin invented the #microprocessor and designed the #4004 #8008 #8080 #z80 and later on via #synaptics #touchscreens and #touchpads .He is a true #pioneer
#retrocomputing #hci #inventors
<img (...)

Yesterday I had the great pleasure to attend a documentary screening and panel session where Prof. #FredericoFaggin was the guest of honour. This was organised by the #Italian Luxembourg Chamber of Commmerce and introduced by the Italian Ambassador to #Luxembourg. #Faggin invented the #microprocessor and designed the #4004 #8008 #8080 #z80 and later on via #synaptics #touchscreens and #touchpads .He is a true #pioneer
#retrocomputing #hci #inventors
<img (...)

I'm still interested in finding good *modern* tutorials for the 8- and 16-bit CPUs. 6502 has several good ones (https://skilldrick.github.io/easy6502/ is the go-to), but I haven't found any nice modern preferably-interactive tutorials for the Z80, 6809, or m68k.

Any of you know of any?

#retrocomputing #z80 #motorola6809

PDS – the Programmers Development System

I was directed towards this recently – it is a means of developing for 8-bit computers using early PCs or an Atari ST developed by Andy Glaister. Information about it seems quite sparse online, the main references seem to be:

• https://www.cpcwiki.eu/index.php/PDS_development_system
• https://www.worldofsam.org/products/pds-development-system (largely a repeat of the above)
• https://trastero.speccy.org/cosas/JL/PDS/Introduccion.html (link via Internet Archive)
• https://lemmings.info/pds-programmers-development-system/ and https://lemmings.info/pds-recreating-the-system/
• It is also talked about and demonstrated here: https://youtu.be/S6DlSfEj0as?si=gEOmOA53eiqXRWc_&t=589

As far as I can tell the original system was developed in the 1980s and there have been two attempts at recreating it since, as listed above.

The original reimplementation is from the Spanish site and provides a schematic and Eagle files. The next link was an attempt at using these design files by importing into KiCAD and getting Gerber files built which seemed to be pretty successful.

I must admit that when I first heard about it, I wondered if it was the same one that Dean Belfield was using with his Tatung Einstein at the 2025 RetroFest, but having read a bit more about it, there are definitely similarities, but I’m not sure its the same. Details of Dean’s setup here:

• http://www.breakintoprogram.co.uk/computers/recreating-my-80s-dev-system-part-1
• https://github.com/breakintoprogram/einstein-ide

It uses a similar principle to the PDS, in that development is performed on the Tatung and then code is transferred across to the target system using a combination of hardware and code running on both sides.

Basic Operation

As I understand things, with the PDS there was an interface card for the PC which linked via a 16-wire IDC cable to another interface card for the target computer. There were versions for the ZX Spectrum, Amstrad CPC, C64 and MSX (and possibly others). I’m only really interested in the ZX Spectrum version.

The PC card is based around the Intel 8255 parallel IO chip sitting on an 8-bit ISA bus. The target interface is usually based around the Z80 PIO (Z84C20) interfacing to the bus of the host system. The PC card supports two target interfaces and both cards include some logic chips to handle addressing and the IO interface.

Details of the 16-way IO link seem very sparse and will probably have to be worked through and inferred from the source code that has been uncovered.

From what I can tell, most of the protocol handling is done in the code and the interfaces are essentially IO “passthroughs”. The target has to run some monitor code to react to PDS commands and interface with the memory as required, setting, reading, updating, and so on.

The CPC wiki seems to be the most complete source of information so far, and includes photos of the remade boards and schematics for the PC card and ZX Spectrum interface.

The PDS Link

The PDS link itself is via a 16-way IDC ribbon cable and 2×8 IDC connectors. Unfortunately I’ve not found a pin-out anywhere so far, but from various sources, this is what I know so far.

This is using the pin numbering from the ZX Spectrum schematic.

Unfortunately the schematic labelling of the two PDS sockets for the PC card is backwards compared to the ZX Spectrum card. Pin 16 for the PC version is GND, but that is pin 1 for the ZX Spectrum version. It would also appear that the socket shroud is also reversed. This means that D0 is pin 15 for the PC and pin 2 for the Spectrum.

The CPC wiki has a photo of the cable used, showing how pins 1-16 are wired to pins 16-1:

The PC Card

The schematic for the PC card can be found on the CPC wiki here: https://www.cpcwiki.eu/index.php/PDS_development_system

Main Components required:

• Intel 8255 Programmable Peripheral Interface (PPI).
• 74LS138 – 3 to 8 line decoder (for the addressing).
• 3x 74LS244 – 8 channel non-inverting buffers.
• 74LS04 – Hex Inverter (only one inverter is used).

It probably goes without saying for this era technology, but everything is 5V TTL levels.

The Intel 8255 PPI

The Intel 8255 Programmable Peripheral Interface (PPI) device provides access to 3 bidirectional 8-bit IO ports. There is a good summary here.

From https://en.wikipedia.org/wiki/Intel_8255:

The 8255 gives a CPU or digital system access to programmable parallel I/O. The 8255 has 24 input/output pins. These are divided into three 8-bit ports (A, B, C). Port A and port B can be used as 8-bit input/output ports. Port C can be used as an 8-bit input/output port or as two 4-bit input/output ports or to produce handshake signals for ports A and B.

The three ports are further grouped as follows:

1. Group A consisting of port A and upper part of port C.
2. Group B consisting of port B and lower part of port C.

There are two address lines that are used to select one of four registers as follows:

The device is selected on the bus when CS is active. It also uses RD and WR to know if it is reading from or writing to the registers.

Things get a bit complicated pretty quickly, but there is a good summary of the various modes of operation on the Wikipedia page, and of course, a comprehensive datasheet.

PC PDS Interface

According to the schematic, this is how the three 8255 IO ports map onto the two PDS connections:

It is also worth noting that the three 74LS244 buffers are enabled in different ways according to the state of PC2. Also, as the enable is active LOW, the inverter on PC2 generates a “NOT PC2” signal, which itself must be LOW to activate IC3A/IC4A – i.e. it is a “active on NOT NOT PC2” signal. PC2 appears to be used to decide which nibble of the data port should be active. It is also passed through to the link control pins (see below).

The 8 control lines map onto the two links in an interesting way. Note this is using “PC interface” pin numbering which as previously mentioned is different to the ZX Spectrum side.

So we can see that PC2 and PC3 are common; that PC0/PC1, PC4/PC5 are swapped; and that PC6 is link 1 only; and PC7 is link 2 only. Recall PC2 appears to select which nibble is active.

When mapped onto the ZX Spectrum card, anything on pins 2,4,6,8 are mapped onto unused pins.

I must say I’m struggling to make sense of this. This seems to be implying that when data is written to one of the PPI IO PORTs, it is striped across both link 1 and 2. Surely it would make more sense to select one or the other and write all 8 data values in one go?

I did wonder if this was related to the different IO modes of the 8255, but on re-reading how the modes work, this still doesn’t make much sense to me.

Unfortunately there doesn’t appear to be any source code for the PC end of things to see what it is doing.

Ok, so finding a print of the traces for the PCB and overlaying them on a light box gives me the following:

I’ve highlighted the connection for D0. We can clearly see that on the PCB D0 for both links is connected, and not only that, it is connected to both input side 2A1 and output side 1Y4 on the /same/ IC. This would make sense for a bi-directional bus, but it is quite a long way from the schematic.

At this point I have to conclude that the schematic is just plain wrong so I’m leaving the PC card for now.

The ZX Spectrum Card

The spectrum side is based on the Z80 PIO (Z8420/Z84C20). There is also a schematic and PCB for that on the CPC wki, but after the experiences with the PC card, I’m now treating it with a little skepticism…

Z80 PIO

There is a lot of information about using the Z80 PIO around. Key references:

• Z80 PIO Users Guide: http://www.z80.info/zip/z80piomn.pdf
• Spectrum Hardware Guide Chapter 15: https://worldofspectrum.net/item/2000357/

Key features:

• Two fully bidirectional 8-bit IO ports.
• Handshaking (not used for the PDS).
• Close compatibility with Z80 control signals (most not used for the PDS).
• Four modes of operation:
  • Byte output
  • Byte input
  • Byte bidirectional (port A only)
  • Bit control
• Six registers addressable via 4 IO ports in the Z80 IO map.

The signals involved in address decoding are:

The use of A5-A7 means that any IO address (IORQ must be active) with A7 clear (CE is active LOW) will be received by the PIO and then A5 and A6 determine the type of access. This gives an IO address of the following:

This equates to some pretty lazy IO address decoding, in that there are many, many equivalent IO addresses that would be decoded by the PIO.

Note that the CPC wiki lists port addresses in the range 0xFBEC-0xFBEF. These are the addresses used with the Amstrad CPC not the ZX Spectrum.

Looking at the provided source code for the ZX Spectrum, it appears to be using IO instructions (OUT, IN) using ports 31 ($1F), 63 ($3F), 95 ($5F), and 127 ($7F).

The schematic shows that /IORQ from the PIO is connected to /IORQ from the Z80 via a SPDT switch which allows selection between Z80 /IORQ and fixed pulled HIGH. This allows the PIO to be inhibited by stopping it responding to /IORQ.

The interrupt control lines for the PIO are not used. INT and IEO are not connected and IEI is pulled HIGH. The hand-shake signals (ARDY, ASTB, BRDY, BSTB) are not used either.

ZX Spectrum PDS Interface

The ZX Spectrum side of the PDS interface has the following:

• PIO PORT A – goes via the 74LS245 octal buffer to the 8 data lines of the PDS link.
• PIO PORT B – goes via the 74LS04 for certain control signals from the PDS link, and the direction control for the 74LS245.
  • Bit 0 – Pin 2 of the PDS interface
  • Bit 1-4 – not used
  • Bit 5 – Pin 7 of the PDS interface
  • Bit 6 – 245 direction control
  • Bit 7 – Pin 5 of the PDS interface

Note that half the PDS control signals are not used for the Spectrum interface. From the previous discussion we can interpret bits 2 and 7 to be the two clock/ack signals. Bit 5’s use is currently unknown. I’ll have to go to the code to see what is going on there.

ZX Spectrum PDS Monitor

I’ve not been able to find any source code for the PC side of things, some assembler has been issued for the target machines, which can be assembled into the run-time PDS monitor for that system.

The PDS Manual does have this to say:

“The software is designed to be machine independent, so the same protocols can be
used regardless of the target machines processor or make. All the communication is basically
the same, there are four major routines, SEND BYTE, GET BYTE and two direction
swapping routines.”

There are three versions of the monitor code for the ZX Spectrum:

• DL0 – the most minimal implementation, providing assembling and downloading only.
• DL1 – the long downloader, providing support for everything apart from the “analyze” command, which requires interrupts.
• DL2 – the full interrupt driven downloader.

The PDS manual contains some information about the ZX Spectrum downloader. Section 6.2 details the three versions of the code and then goes on to describe the available commands.

To get a feel for how the monitor functions, and some insights into how the hardware works, I’m looking at some extracts of DL0.

Code initialisation

START DI
      LD A,255
      OUT (127),A ; $7F=CB=$FF Mode 3
      OUT (63),A  ; $3F=DB=$FF PORT B=$FF (B0-7=HIGH)
      LD A,63
      OUT (127),A ; $7F=CB=$3F B6/B7=OUTPUT B0-B5=INPUT
      LD A,255
      OUT (95),A  ; $5F=CA=$FF Mode 3
      OUT (95),A  ; $5F=CA=$FF A0-A7=INPUT

CTRL = $FF means all bits of the control register are set. The Z8020 datasheet lists the control register as follows:

Where M1/M0 signify which of the four modes is to be used. In this case both PORTs are set to Mode 3, which allows for either IN or OUT on a per bit basis. I am guessing the writing of $FF to DB (PORT B DATA) happens to ensure that when then ports are configured as 2 OUT and 6 IN, the OUT lines are already HIGH, giving a known starting point.

Note: Setting B6 to HIGH means that the direction control for the 74LS245 will be LOW as it goes through an inverter. This sets the 74LS245 to work in the direction “B to A” which would correspond to when PORT A is set to all INPUTs later in the code.

GETBYTE

This is the lowest level function and it retrieves a single byte of data from over the PDS interface. This is used during the main protocol handling to both obtain commands over PDS and then receive data.

The essential function is as follows:

• Ensure PORT A setup for INPUT
• WAIT for a change in the PC->TARGET CLOCK
• Read the data from PORT A
• WRITE the TARGET->PC CLOCK/ACK
• Toggle the two CLOCK signals ready for next time
• Return

;On first entry D=64=b0100 0000
GETBYTE IN A,(63)  ;Read DB - control values
        XOR D      ;Toggle FLAGS
        RRCA       ;Pushes B0->Carry
        JC GETBYTE ;Wait for B0 to have changed
        IN A,(31)  ;Read data from DA
        LD E,A     ;And store in E
        LD A,D     ;Reload FLAGS
        OUT (63),A ;And write them out ie write B7
        XOR 129    ;Toggle B0+B7 (129, $81) for next time
        LD D,A     ;And store back in D
        RET

So I think the key features for this are:

• Control FLAGS are stored in the D register. Only B0, B6, B7 are significant. B0 is what we’re looking for on reception; B7 is what we will send in acknowledgement; B6 is the DIRection and is preset to INPUT for this.
• FLAGS are initialised to 64 i.e. B0=B7=0; B6=1.
• Every pass through the GETBYTE function toggles B0 and B7 between b0xxxxxx0 and b1xxxxxx1.
• Read data is stored in the E register.
• RRCA is used to take the read in control value and shift B0 into the carry flag so it can be checked with JC (JP C).
• Nothing else in the code works with the D register so it will always reflect the required status of the required PORT B CTRL word flags.

So this shows how the flags change through several passes of the function:

D=64               D=0100 0000 ($40)
CALL GETBYTE       D=1100 0001 ($C1)
CALL GETBYTE       D=0100 0000 ($40)
CALL GETBYTE       D=1100 0001 ($C1)

The PDS Manual describes the protocol as follows:

“Note that the protocol does not set the control lines directly, but toggles the lines to
communicate. All the protocols are designed so one computer can never get ahead of the
other, even if there is a big speed difference. There are no error checking protocols, as the
interfaces are very reliable, and error checking will slow down processes, and no real action
can be taken, even if an error was detected.”

Main Loop

The main loop essentially reads a byte from the interface and treats it as a control command. It will keep doing this until it finds a command it can process.

MAINLOOP CALL GETBYTE ;Get 'command byte'
         LD A,E
         CP 180	      ;Download code into aabb, len=ccdd
         JZ DLOAD
         CP 183       ;Select bank aa
         JZ SBANK
         CP 181       ;Execute code from aabb?
         JNZ MAINLOOP ;Not recognised - keep looping.

The comments are the original comments. There is a not a function for command 181, as this relies on “fall through”. It is the next function in the code.

The commands have values 180-187 as follows:

• 180: Download code
• 181: Jump to an address
• 182: Upload memory
• 183: Select bank
• 184: Send all registers to the main computer
• 185: Get registers from the main computer
• 186: Trace code buffer
• 187: Return analyze address

The various functions and message protocol layer are described in the PDS manual, so I won’t go into them in detail here, but by way of example, here is the description for 181:

The corresponding code is as follows:

;
; Function 181, Execute code from aabb
;
        CALL GETBYTE
        LD H,E  ;Get address of routine
        CALL GETBYTE
        LD L,E
        LD BC,MAINLOOP
        PUSH BC ;Put return address on stack and jump to routine
        JP (HL)

It is interesting to note that in the PDS manual, some commands appear to start with a padding byte (179). Apparently this is to ensure that all command messages are an even number of bytes long.

Any variable length commands (e.g. download) include an expected length field.

To retrieve data from the target, the protocol has the concept of “reverse ports”. After receiving upload command, ports are reversed to allow the sending of the appropriate amount of data before being reversed once again to restore the original direction ready for the next command.

Uploading is not supported in the simple D0 downloader. That requires the more complete D1 or D2 implementations. I’ve not gone into more detail here.

Conclusion

I’m going to leave this here for now. I think I’ve got a reasonable grasp of what is going on and I’d like to see if I can recreate the interfaces used at some point.

The ZX Spectrum one should be relatively straight forward. To do something with the PC end though is going to require a lot of work as I just don’t believe I can rely on that schematic.

I have to question though whether it would be worth it though. Given that an Intel 8255 is no longer available I’ll be using reclaimed parts and I also don’t have a PC with ISA anymore. I must admit I am wondering if an alternative PC end would be possible using a microcontroller to implement the PDS protocol and connect to the PC over USB (for example).

In fact, with something like a Raspberry Pi Pico, it would be quite possible to implement the entire target interface through to emulating the Z80 PIO on the ZX Spectrum board and potentially have a replacement system that is “USB direct to Spectrum”.

At this point of course, this is not really the PDS anymore and I’m sure there are already many modern alternatives to getting code running on a ZX Spectrum from a modern system, so that too might be a little pointless. And that is before we get into emulation.

But for its time, this is a really interesting system and it is a shame that information about it seems to have slowly disappeared.

I am still quite keen to recreate it though, so I might be on the look out for an old PC with ISA…

Oh, and as always, if you know about the PDS and are able to confirm or refute anything I’ve said here, do let me know in the comments!

Kevin

More of our lovely FREEZE-ZX readers sharing their love for the new issue.
Grab yourself a copy from:
https://freeze64.com/freeze-zx/
#ZXspectrum #Z80 #Speccy #IndieGames #RetroGames

... and it's done! All 23 entries are accounted for 😄

Download them, try them on the real hardware or on your favorite emulator (I always suggest MEKA and Emulicious) and then let the author(s) know your opinion on the forum topic linked to every entry.

Join SMSPower! today! 🤩
https://www.smspower.org

#joinSMSPower #8bit #SEGA #Z80 #retrodev #videogames

I realised something today. I love #programming 8-bit code, but I don’t like emulators. If you want to do some writing, let’s say, on an 8-bit computer, there’s a painful isolation between host and client that puts you off: file access, mouse pointer, copy/paste, etc. You can’t change the number of lines on the screen because it’s simulating a CRT from the 80s.

So what if I were to strap an 8-bit CPU emulator to the terminal and just write modern command-line / terminal software in 8-bit assembly?

Yes, CP/M and even MS-DOS simulators for the terminal already exist; you can run #Z80 code in your terminal without an emulated “screen” however these simulators still rely upon a BIOS style API for an 80s computer. You don’t have access to the full file system or other features of the machine.

This is just an idea I’m toying with, nothing serious. I know it’s not worth pursuing but I just want to put the idea out there so I can move on from it. We should be able to imagine beyond the confines of a specific 80s computer.

#retrocomputing #retrodev #retroprogramming

More of our lovely FREEZE-ZX Readers continue to share their love for the new issue, which features the fabulous Chase H.Q. and an interview with its graphic artist Bill Harbison.
Grab your copy from:
https://freeze64.com/freeze-zx/
#ZXSpectrum #Z80 #Speccy

The first three issues of FREEZE-ZX magazine for #ZXspectrum gaming enthusiasts are available in stock.
Grab yourself a copy or three from:
https://freeze64.com/freeze-zx/
#Speccy #Z80 #ChaseHQ #IndieGaming #RetroGames #MontyMole

# Calling all #ZXSpectrum Enthusiasts #
All three issues 01,02,03 of FREEZE-ZX ‘zine are now back in stock!
Grab yourself a copy or three from:
freeze64.com/freeze-zx/
#Speccy #Z80 #IndieGames #RetroGames

Retroparty war wieder genial ❤️
Da wir an die Kapazitätsgrenze geraten, wird die nächste wohl an einer anderen Location stattfinden. Dieses mal stand die Party unter dem Motto Atari. Ich hoffe ein paar Amiganer konnten Vorurteile abbauen, ich schon 😉

https://retrocomputer-dresden.de/retroparty-2026-one/

#retrocomputing #atari #agonlight #z80 #dresden #retro #party

BIG ❤️🙏 to our FREEZE-ZX Readers who have started sharing their love for the new issue no.03.
Grab yourself a copy from:
https://freeze64.com/freeze-zx-issue-3/
#ZXSpectrum #Z80 #Speccy #IndieGames #RetroGaming

Der AgonLight ist kein Raspberry Pi, sondern ein echter 8-Bit-Computer mit „Bare-Metal“-Design. Er kombiniert eine 50 MHz eZ80-CPU von Zilog mit einem ESP32 als Grafik- und Sound-Co-Prozessor.
Bootet in Millisekunden direkt in BBC BASIC. Wer Technik ohne Abstraktions-Layer verstehen will, bekommt hier direkten Zugriff auf CPU, Speicher und Register.

https://retrocomputer-dresden.de/agonlight_intro/

#agonlight #z80 #retrocomputing #bbcbasic #dresden #retrocomputerdresden

Can Claude Write Z80 Assembly Code?

https://web.brid.gy/r/https://hackaday.com/2026/04/19/can-claude-write-z80-assembly-code/

The new issue of FREEZE-ZX issue 03 is now available to buy from:
https://freeze64.com/freeze-zx-issue-3/
Lots of new and exclusive #ZXSpectrum content for you to devour, as well as a look back at some of the best and worst games on our rubber-keyed hero.
#Z80 #Speccy #IndieGames #RetroGaming

FREEZE-ZX issue 03 is now available to buy from:
https://freeze64.com/freeze-zx-issue-3/
The issue includes a whole host of old and new #ZXspectrum content to enjoy. Stock is limited and so you’ll need to be quick to secure a copy.
#Speccy #Z80 #IndieGames #RetroGaming #RetroGames

I’m currently packing and labelling the next large batch of preorders of FREEZE-ZX issue 03.
I’ll email all the lucky recipients tomorrow morning once all copies have been posted.
https://freeze64.com/freeze-zx-issue-3/
#ZXSpectrum #Z80 #Speccy #IndieGames

FREEZE-ZX issue 03 has arrived!
I’m going to pack and post a large batch this afternoon.
Lucky recipients will be sent an email this evening.
Another large batch tomorrow, and the final batch on Monday.
Lots to do!
https://freeze64.com/freeze-zx-issue-3/
#ZXSpectrum #Z80 #Speccy #IndieGames

The colour proof for FREEZE-ZX issue 03 arrived today and it looks GOOOOORGEOUS!
Pre-orders should start posting out next week.
freeze64.com/freeze-zx-issue-3
#ZXSpectrum #Z80 #Speccy #Retrogaming #IndieGames

The colour proof for FREEZE-ZX issue 03 arrived today and it looks GOOOOORGEOUS! Pre-orders should start posting out next week.
https://freeze64.com/freeze-zx-issue-3/
#ZXSpectrum #Z80 #Speccy #Retrogaming #IndieGames

45 days until #RetroFest 2026 in Swindon. #PERQ status:

• Flaky Z80-based I/O subsystem: sometimes the #Z80 jumps off the tracks and executes nonsense code
• Disk boots fail: the microcode attempts to load blocks far beyond the end of the disk

Trying today: DIY diagnostic microcode

Who Had “New OS For The #Z80” On Their 2026 Bingo Card?

https://hackaday.com/2026/04/12/who-had-new-os-for-the-z80-on-their-2026-bingo-card/

Over coffee this morning I read Z80 assembly code from 1982, as one does. It was very relaxing. #retrocomputing #Z80

POV: #PERQ hardware debugging, as usual. The #Z80 (serving as an I/O coprocessor) is behaving strangely: fetching instruction bytes without toggling the M1 pin, jumping to random locations at around 47uS after coming out of reset; what's going on here?

This time next week I’ll be sending FREEZE‑ZX Issue 03 to print — the long‑awaited next chapter is nearly here.
You can preorder your copy today from:
https://freeze64.com/freeze-zx-issue-3/
Issue 02 sold out fast, so grab No.03 while you can.
#ZXSpectrum #Z80 #Speccy #SinclairSpectrum

Even @llamasoft_ox gets a mention in this issue with the brilliant Laser Zone.

The #Z80 #cpu is no longer produced since 2024, what to do if you need to replace a broken one? The picoZ80 is a drop-in replacement based on the RP2350 #microcontroller

Soon to be released.

https://eaw.app/picoz80/

#oshw #opensource #retrocomputing #raspberrypi

The #Z80 #cpu is no longer produced since 2024, what to do if you need to replace a broken one? The picoZ80 is a drop-in replacement based on the RP2350 #microcontroller

Soon to be released.

https://eaw.app/picoz80/

#oshw #opensource #retrocomputing #raspberrypi

The #Z80 #cpu is no longer produced since 2024, what to do if you need to replace a broken one? The picoZ80 is a drop-in replacement based on the RP2350 #microcontroller

Soon to be released.

https://eaw.app/picoz80/

#oshw #opensource #retrocomputing #raspberrypi

The #Z80 #cpu is no longer produced since 2024, what to do if you need to replace a broken one? The picoZ80 is a drop-in replacement based on the RP2350 #microcontroller

Soon to be released.

https://eaw.app/picoz80/

#oshw #opensource #retrocomputing #raspberrypi

The #Z80 #cpu is no longer produced since 2024, what to do if you need to replace a broken one? The picoZ80 is a drop-in replacement based on the RP2350 #microcontroller

Soon to be released.

https://eaw.app/picoz80/

#oshw #opensource #retrocomputing #raspberrypi

EXCLUSIVO: O “Santo Graal” da Gradiente é encontrado em Manaus!!!

https://retropolis.com.br/2026/04/01/exclusivo-o-santo-graal-da-gradiente-e-encontrado-em-manaus/

#MundoRetro #gradiente #MSX #MSX2 #sega #Tectoy #z80

Upgrade day! My blue box #RC2014 Pro gets a bump from 3.5.0 to 3.6.0.
#RomWBW #CPM #ZSystem #Z80

Lilbits: Samsung Galaxy Z Fold 8 Wide, Razer Blade 16, and more fallout from Chuwi’s processor mixup

Two recent laptops from Chinese PC maker Chuwi that were supposed to ship with AMD Ryzen 5 7430U processors actually had Ryzen 5 5500U chips inside. That means instead of getting a processor with a Zen 3 CPU, customers were getting notebooks with chips featuring AMD’s older Zen 2 architecture.

But the only way to prove this was to actually open up the computer and remove the CPU cooler to look […]

#msx #msx2 #z80 #retrogaming #japanese #ai #retrocomputing

#msx #msx2 #z80 #retrogaming #japanese #ai #retrocomputing

Cheeka's Exploits, a plattform game in #BASIC & #machinecode from #yourcomputer magazine.

Download:
https://spectrumcomputing.co.uk/entry/910/ZX-Spectrum/Cheekahs_Exploits

#zxspectrum #z80 #assembler #retrogaming

Cheeka's Exploits, a plattform game in #BASIC & #machinecode from #yourcomputer magazine.

Download:
https://spectrumcomputing.co.uk/entry/910/ZX-Spectrum/Cheekahs_Exploits

#zxspectrum #z80 #assembler #retrogaming

Cheeka's Exploits, a plattform game in #BASIC & #machinecode from #yourcomputer magazine.

Download:
https://spectrumcomputing.co.uk/entry/910/ZX-Spectrum/Cheekahs_Exploits

#zxspectrum #z80 #assembler #retrogaming

Cheeka's Exploits, a plattform game in #BASIC & #machinecode from #yourcomputer magazine.

Download:
https://spectrumcomputing.co.uk/entry/910/ZX-Spectrum/Cheekahs_Exploits

#zxspectrum #z80 #assembler #retrogaming

Cheeka's Exploits, a plattform game in #BASIC & #machinecode from #yourcomputer magazine.

Download:
https://spectrumcomputing.co.uk/entry/910/ZX-Spectrum/Cheekahs_Exploits

#zxspectrum #z80 #assembler #retrogaming

Aujourd’hui :
💻 IA
☁️ cloud
⚡ GPU
En 1982 :
📼 cassette
⌛ patience
🧠 imagination
Le Sharp MZ-80A en faisait beaucoup avec très peu.
Un des plus beau de la série MZ non ?

#RetroComputing #TechHistory #Z80 #Silicium #Heritage #Toulouse

Z80 Sans – a disassembler in a font (2024)

https://github.com/nevesnunes/z80-sans

#HackerNews #Z80 #Sans #Disassembler #Font #Programming #RetroTech #OpenSource

ual news: ual is getting cual

The good news is that apart from the embedded systems targeted through TinyGo, the ual programming language is getting a tiny C backend called cual that allows us to target small machines, notably the Z80, with support for some of its most popular platforms: the ZX Spectrum and CP/M to get started with.

The bad news is that the weekend was too short and it's going to take me a while longer to release ual 0.7.6 the way I'd like.

#ual #programming #forth #rustlang #golang #foss #opensource #compsci #cpm #z80 #retrocomputing #zxspectrum #speccy #spectrum

Oh no! This will lead to a massive #shortage of #Z80 #CPUs this year! We'll be hearing stories of mysterious break-ins where nothing more than a #Commodore #C128 was stolen from the basement game room. It's going to be terrible!

https://github.com/HarryR/z80ai

#llm #ai #retrocomputing

I'm in a most excellent mood! A long long time ago, I got a fancy #MiSTer #FPGA. For those unaware, this device emulates everything from old #Zilog #Z80 systems to low end PCs and arcade machine - or rather, it doesn't exactly emulate them - it sort of becomes the old legacy hardware itself, meaning you'll have nearly clock cycle perfect emulation.

Anyhoo, I also got a #MT32pi for it, which is a thing that emulates old #Roland #MIDI hardware that nobody back in the day could afford. Many of the early DOS titles support this, and it's an absolute joy to listen to. There's a whole sad story to the MT32-Pi project, but that's for another day.

Sadly, it never worked in my setup - until today! I had it for years and years but finally I put in the effort - a lot of measuring and some soldering and now it actually works! Delicious music in old #DOS games! I thought the thing was for sure fried, so I couldn't be happier!

Have an excellent weekend everyone! 🙂

#retrogaming #pcgaming

Time for another image viewer for #AgonLight #Console8 - this time, PCX format. There are a number of reasons why I chose to display this format on the Agon/Console8.
* It is an already existing format
* The format is supported by modern tools, including #GIMP
* It uses a very simple form of compression ideal for 8 bit CPUs
* The specific choice of 16 colours has additional benefits:
* The 16 colours are chosen from within the available 64 colour palette
* The 16 colours allows the image to be sent to the VDP with 2 pixels per byte, speeding up the transfer
I've attached a sample here to show just the quality of the resolution and colour depth. #z80 source code and binary is at:
https://github.com/sijnstra/agon-projects/tree/main/PCXview
#retrocomputing #image #viewer #ez80

EFT Z80 heavy-payload agricultural drone🚁
The new spraying system with an 80L tank, new flexible pumps, and four high-power centrifugal nozzles...
delivering 36 L/min of atomized spray, stable powerful flow and thorough spray.
#eft #eftdrone #sprayingdrone #nozzle #z80 #agriculturedrone #uav #modernfarming #agricultureindustry #drones
https://www.effort-tech.com/en/z80

@shieladixon @edbrindley Oh, wow. That's not bad for a "firsty".

And here we have yet another sound card which could be made to work with your #midi interface ... imagine how cool it must be to have the SID, AY and OPL3 perform together ...

Also, it's so cool to see #rc2014 and the #opl3 work together so well. #Z80 and #CPM80 ... made to last ...