Collecting retrocomputers is fun, especially when you find fully-functional examples that you can plug in, switch on, and start playing with. Meanwhile, others prefer to find the damaged examples and nurse them back to health. [polymatt] can count himself in that category, as evidenced by his heroic rescue of an 1993 IBM ThinkPad Tablet.

The tablet came to [polymatt] in truly awful condition. Having been dropped at least once, the LCD screen was cracked, the case battered, and all the plastics were very much the worse for wear. Many of us would consider it too far gone, especially considering that replacement parts for such an item are virtually unobtainable. And yet, [polymatt] took on the challenge nonetheless.

Despite its condition, there were some signs of life in the machine. The pen-based touch display seemed to respond to the pen itself, and the backlight sort of worked, too. Still, with the LCD so badly damaged, it had to be replaced. Boggling the mind, [polymatt] was actually able to find a 9.4″ dual-scan monochrome LCD that was close enough to sort-of fit, size-wise. To make it work, though, it needed a completely custom mount to fit with the original case and electromagnetic digitizes sheet. From there, there was plenty more to do—recapping, recabling, fixing the batteries, and repairing the enclosure including a fresh set of nice decals.

The fact is, 1993 IBM ThinkPad Tablets just don’t come along every day. These rare specimens are absolutely worth this sort of heroic restoration effort if you do happen to score one on the retro market. Video after the break.

On today’s installment of UE1 vacuum tube computer construction, we join [David Lovett] once more on the Usagi Electric farm, as he determines just how much work remains before the project can be called done. When we last left off, the paper tape reader had been motorized, with the paper tape being pulled through smoothly in front of the photodiodes. This left [David] with the task to create a PCB to wire up these photodiodes, put an amplification circuit together (with tubes, of course) to amplify the signal from said photodiodes, and add some lighting (two 1-watt incandescents) to shine through the paper tape holes. All of this is now in place, but does it work?

The answer here is a definite kinda, as although there are definitely lovely squiggles on the oscilloscope, bit 0 turns out to be missing in action. This shouldn’t have come as a major surprise, as one of the problems that Bendix engineers dealt with back in the 1950s was effectively the same one: they, too, use the 9th hole on the 8-bit tape as a clock signal, but with this whole being much smaller than the other holes, this means not enough light passes through to activate the photodiode.

Here, the Bendix engineers opted to solve this by biasing the photodiode to be significantly more sensitive. This seems to be the ready-made solution for the UE1’s tape reader, too. After all, if it worked for Bendix for decades, surely it’ll work in 2024.

Beyond this curveball, the rest of the challenges involve getting a tape punched with known data on it so that the tape reader’s output can actually be validated beyond acknowledging the presence of squiggles on the scope display. Although the tape guiding mechanism seems more stable now, it also needs to be guided around in an endless loop due to the way that the UE1 computer will use the tape. Much like delay line memory, the paper tape will run in an endless loop, and the processor will simply skip over sections until it hits the next code it needs as part of a loop or jump.

With semi-modern components, paper tape is easy to handle. Automatic tape feed only adds a little complexity.

The common wisdom these days is that even if we wanted to get back to the Moon the way we did in the 1960s, we’d never be able to do it. Most of the blame for that usually falls on the loss of institutional knowledge thanks to skilled minds and hands that have been stilled by the passage of time, but the real kicker would be finding replacements for all the parts that we used back then that just aren’t made anymore. A similar problem exists for those seeking to recreate the circuits that graced the pages of the many magazines that catered to electronics hobbyists back in the day.

Take this “Space Age Decimal Computer” reproduction that [Bob Alexander] undertook. Smitten with the circuit after seeing our story about a 1966 article detailing its construction, he decided to roll one of his own. That proved to be far harder than he thought it would be. The original circuit, really little more than an adding machine using a rotary telephone dial as an input device, used neon lamp ring buffers for counting, The trouble is, while NE-2 neon lamps are still made, they aren’t made very precisely. That makes it difficult to build a working ring buffer, which relies on precise on and off voltages. That was even a problem back then; the author suggested buying 100 lamps and carefully characterizing them after aging them in to get the 60 lamps needed.

In the end, [Bob] settled for modifying the circuit while making the build look as close as possible to the original. He managed to track down the exact model of enclosure used in the original. The front panel is populated with a rotary dial just like the original, and the same neon lamps are used too, but as indicators rather than in ring buffers. Behind the scenes, [Bob] relied on 7400-series counters and decoders to make it all work — kudos for sticking with 1970s tech and not taking the easy way out with an Arduino.

The video below goes into more detail on the build and the somewhat kludgy operation of the machine, with a few excellent [Tom Lehrer] references and a nice Cybertruck dunk to boot.

If you think of Apple today, you probably think of an iPhone or a Mac. But the original Apple I was a simple PC board and required a little effort to start up a working system. [Artem] has an Apple I reproduction PCB, and decided to build it on camera so we could watch.

For the Apple I, the user supplied a keyboard and some transformers, so [Artem] had to search for suitable components. He wisely checks the PCB to make sure there are no shorts in the traces. From there, you can watch him build the machine, but be warned: even with speed ups and editing, the video is over an hour long.

If you want to jump to the mostly working device, try around the 57-minute mark. The machine has a basic ROM monitor and, of course, needs a monitor. There was a small problem with memory, but he eventually worked it out by inhibiting some extra RAM on the board. Troubleshooting is half of the battle getting something like this.

Want to look inside the clock generator chip? Or skip the PCB and just use an FPGA.

These days, the vast majority of portable media users are storing their files on some kind of Microsoft-developed file system. Back in the 1980s and 1990s, though, things were different. You absolutely could not expect a floppy disk from one type of computer to work in another. That is, unless you had a magical three-format disk, as [RobSmithDev] explains.

The tri-format disk was a special thing. It was capable of storing data in Amiga, PC, and Atari ST formats. This was of benefit for cover disks—a magazine could put out content for users across all three brands, rather than having to ship multiple disks to suit different machines.

[RobSmithDev] started investigating by reading the tri-format disk with his DiskFlashback tool. The tool found two separate filesystems. The Amiga filesystem took up 282 KB of space. The second filesystem contained two folders—one labelled PC, the other labelled ST. The Atari ST folder contained 145KB of data, while the PC folder used 248 KB. From there, we get a breakdown on how the data for each format is spread across the disk, right down to the physical location of the data. The different disk formats of each system allowed data to be scattered across the disk such that each type of computer would find its relevant data where it expected it to be.

It’s a complex bit of disk engineering that allowed this trick to work, and [Rob] explains it in great detail. We love nitty gritty storage hacks around here. Video after the break.

[Thanks to Mathieuseo for sending this in!]

If you ask someone who grew up in the late 1970s or early 1980s what taught them a lot about programming, they’d probably tell you that typing in programs from magazines was very instructive. However, it was also very boring and error-prone. In fact, we’d say it was less instructional to do the typing than it was to do the debugging required to find all your mistakes. Magazines hated that and, as [Tech Tangents] shows us in a recent video, there were efforts to make devices that could scan barcodes from magazines or books to save readers from typing in the latest Star Trek game or Tiny Basic compiler.

The Cauzin Softstrip was a simple scanner that could read barcodes from a magazine or your printer if you wanted to do backups. As [Tech Tangents] points out, you may not have heard of it, but at the time, it seemed to be the future of software distribution.

We were impressed that [Tech Tangent] had enough old magazines that he had some of the original strips. Byte Magazine had tried to promote a similar format, but there was no hardware made to read those barcodes.

Of course, there were other systems. For example, the HP-41C famously had a barcode scanner, although creating your own was clunky unless you reverse-engineered the “proper” format (which was done). The basic hardware used there also worked with Byte’s format, but you still had to interface the odd scanner to your computer.

Cauzin sidestepped all this with their product, which was simple-to-interface hardware with software support for the major platforms. However, by the time it was on the market, cheap magnetic media and modem-based bulletin boards were destroying interest in loading software from paper.

This is a great look at an almost forgotten technology. You could probably build something modern to scan these if you had the urge. These days, it would be easy enough to design your own system. Modern laser printers would probably make very dense barcodes.

We wouldn’t suggest making a Cauzin guitar, though. These days we have QR codes and even colorful barcodes.

In a new installment on computer history, [Bradford Morgan White] takes us through the sordid history of Cyrix, as this plucky little company created the best math co-processors (FasMath) and then a range of interesting x86-compatible CPUs that would give competing x86 CPUs a run for their money. Even though Cyrix played by the rules of licensing agreements, Intel would keep suing Cyrix repeatedly since the 1980s well into 1990s, for a total of seventeen times until Cyrix counter-sued for patent violations in May of 1997.

This case was settled between Cyrix and Intel, with a cross-licensing agreement established. Unfortunately these mounting legal costs and the stresses of keeping up with the competition (i.e. Intel) was proving too much and Cyrix was sold off to National Semiconductor, who wasn’t enthusiastic about competing with Intel. After this Cyrix got split up into Geode (sold to AMD) and Cyrix Technologies (sold to VIA). Interestingly, VIA’s x86 patent licenses and patents ended up being the foundation of Zhaoxin: a joint venture between VIA and Shanghai’s government which produces x86 CPUs for primarily the Chinese market.

We looked at the Cyrix Cx486DLC processor a while ago, and why their 386 upgrade options were perhaps not that great. Their later CPUs have however left a strong legacy that seems to endure in some way to this day.

According to [MTSI], if you used a Z80 chip back in the 1980s, it almost certainly passed through the sole Fairchild Sentry 610 system that gave it the seal of approval.

The Sentry was big iron for its day. The CPU was a 24-bit device and ran at a blistering 250 kHz. Along with a tape drive and a specialized test bed, it could test Z80s, F8s, and other Mostek products of the day. There was a disk drive, too. The 26-inch platters stored under 10 kilobytes. Despite the relatively low speed of the CPU, the Sentry could test devices running up to 10 MHz, which was plenty for the CPUs it was testing. The actual test interface ran at 11 MHz and used an exotic divider to generate slower frequencies.

According to the post, an informal count of the number of chips in the device came up with around 60,000. That, as you might expect, took a huge power supply, too.

From some 1975 corporate literature:

“Optimized for engineering, sophisticated production needs, QA and test center operations, the Sentry 610 is the most versatile analytical tester available for engineering and production. It can perform the widest range of tests for the broadest range of components. At user option, the Sentry 610 can perform high-speed MaS/LSI, PCB, and bipolar tests simultaneously. It offers complete testing at the wafer level and through automatic handlers at full-rated device speeds up to 10 MHz. The wide choice of peripherals gives the Sentry 610 system massive data handling capacity to manipulate, analyze, compute and generate reports on test procedures in analyzing MaS/LSI.”

These days, you are as likely to stick test hardware on the IC as have a big machine on the outside. And even then, you probably wouldn’t have something this elaborate. But in its day, this was high-tech for sure.

The Z80 sure has had a long lifespan. It shouldn’t surprise you that Z80s need to be tested, just like everything else.

Building a paper tape reader by itself isn’t super complicated: you need a source of light, some photoreceptors behind the tape to register the presence of holes and some way to pull the tape through the reader at a reasonable rate. This latter part can get somewhat tricky, as Usagi Electric‘s [David Lovett] discovered while adding this feature to his vacuum tube-era DIY reader. This follows on what now seems like a fairly simple aspect of the photosensors and building a way to position said photosensors near the paper tape.

As the feed rate of the paper tape is tied to the reading speed, and in the case of [David]’s also contains the clock for the custom tube-based UE1 computer, it determines many of the requirements. With 8 bits per line, the tape forms the ROM for the system, all of which has to be executed and used immediately when read, as there is no RAM to load instructions into. This also necessitates the need to run the tape as an endless loop, to enable ‘jumping’ between parts of this paper-based ROM by simple masking off parts of the code until the desired address is reached.

For the motor a slot car motor plus speed-reduction gear was chosen, with a design to hold these then designed in FreeCAD. Courtesy of his brother’s hobby machine shop and a CAD professional’s help, producing these parts was very easy, followed by final assembly. Guides were added for the tape, not unlike with a cassette player, which allowed the tape to be pulled through smoothly. Next up is wiring up the photodiodes, after which theoretically the UE1 can roar into action directly running programs off paper tape.

Retro computing enthusiasts, rejoice! HIDman, [rasteri]’s latest open source creation, bridges the gap between modern USB input devices and vintage PCs, from the IBM 5150 to machines with PS/2 ports. Frustrated by the struggle to find functioning retro peripherals, [rasteri] developed HIDman as an affordable, compact, and plug-and-play solution that even non-techies can appreciate.

The heart of HIDman is the CH559 microcontroller, chosen for its dual USB host ports and an ideal balance of power and cost-efficiency. This chip enables HIDman’s versatility, supporting serial mice and various keyboard protocols. Building a custom parser for the tricky USB HID protocol posed challenges, but [rasteri]’s perseverance paid off, ensuring smooth communication between modern devices and older systems.

Design-wise, the project includes a thoughtful circuit board layout that fits snugly in its case, marrying functionality with aesthetics. Retro computing fans can jump in by building HIDman themselves using the files in the GitHub repository, or by opting for the ready-made unit.

[Classic Microcomputers] read in a book that there was a computer-generated film made in the late 1960s, and he knew he had to watch it. He found it and shared it along with some technical information in the video below.

Modern audiences are unlikely to be wowed by the film — Permutations — that looks like an electronic spirograph. But for 1968, this was about as high tech as you could get. The computer used was an IBM mainframe which would have cost a fortune either to buy or to rent the hours it would take to make this short film. Now, of course, you could easily replicate it on even your oldest PC. In fact, we are surprised we haven’t seen any recreations in the demoscene.

The end credits list [John Whitney] working under an IBM research grant as the author of the film. The programming was by [Jack Citron], and it was apparently put together at the UCLA School of Medicine.

According to [Classic Microcomputers], the display was static and black and white, but animation on 16mm film and color filters made it more interesting.

Was this the birth of the demoscene? Usually, when we watch old IBM videos, it is of the data center, not the data!

If Apple has a reputation for anything other than decent hardware and excellent industrial design, it’s for selling its products at extremely inflated prices. But there are some alternatives if you want the Apple experience on the cheap. Buying their hardware a few years out of date of course is one way to avoid the bulk of the depreciation, but at the extreme end is this working Mac clone that cost just $14.

This build relies on the fact that modern microcontrollers absolutely blow away the computing power available to the average consumer in the 1980s. To emulate the Macintosh 128K, this build uses nothing more powerful than a Raspberry Pi Pico. There’s a little bit more to it than that, though, since this build also replicates the feel of the screen of the era as well. Using a “hat” for the Pi Pico from [Ron’s Computer Videos] lets the Pico’s remaining system resources send the video signal from the emulated Mac out over VGA, meaning that monitors from the late 80s and on can be used with ease. There’s an option for micro SD card storage as well, allowing the retro Mac to have an incredible amount of storage compared to the original.

The emulation of the 80s-era Mac is available on a separate GitHub page for anyone wanting to take a look at that. A VGA monitor is not strictly required, but we do feel that displaying retro computer graphics on 4K OLEDs leaves a little something out of the experience of older machines like this, even if they are emulated. Although this Macintosh replica with a modern e-ink display does an excellent job of recreating the original monochrome displays of early Macs as well.

As we all know, when developing software for any platform or simply hacking a bit of code to probe how something works, the ability to deploy code rapidly is a huge help. [Martin Donlon], aka [wickerwaka], is well known in retro gaming and arcade hardware reverse engineering circles and had the usual issues figuring out how an arcade CPU board worked while developing a MiSTer core. Some interesting ASICs needed quite a bit of poking, and changing the contents of socketed ERPOMs is a labour-intensive process. The solution was PicoROM, a nicely designed ROM emulator in a handy DIP-32 form factor.

As the title suggests, PicoROM is based on the Raspberry Pi RP2040. It emulates an 8-bit ROM up to 2MBits in size with speeds up to 100ns. Since it uses the RP2040, USB connectivity is simple, enabling rapid uploading of new images to one (or more) PicoROMs in mere seconds. A vertically orientated USB-C connector allows multiple PicoROMs to be cabled to the host without interfering with neighbouring hardware. The firmware running on core 1 passes data from the internal 264K SRAM, using the PIO block as a bus interface to the target. A neat firmware feature is the addition of a mechanism to use a ROM region as a bidirectional control channel, which the software running on the target can use to communicate back to the host computer. This allows remote triggering of actions and the reporting of responses. Responses which may not be physically observable externally. [Martin] is using this feature extensively to help probe the functionality of some special function chips on the target boards, which is still a slow process but helped massively by reducing that critical software iteration time. The PCB was designed with KiCAD. The project files for which can be found here.

This isn’t the first time we’ve seen the RP2040 used for ROM emulation; here’s a pile of wires that does the same job. It just isn’t as pretty. Of course, if you really must use EPROMs, then you could give this sweet programmer a look over.

Artificial intelligence has always been around us, with [Timothy J. O’Malley]’s 1985 book on AI projects for the Commodore 64 being one example of this. With AI defined as being the theory and development of systems that can perform tasks that normally requiring human intelligence (e.g. visual perception, speech recognition, decision-making), this book is a good introduction to the many ways that computer systems for decades now have been able to learn, make decisions and in general become more human-like. Even if there’s no electronic personality behind the actions.

In the book’s first chapter, [Timothy] isn’t afraid to toss in some opinions about the true nature of intelligence and thinking. Starting with the concept that intelligence is based around storing information and being able to derive meaning from connections between stored pieces of information, the idea of a basic AI as one would use in a game for the computer opponent arises. A number of ways of implementing such an AI is explored in the first and subsequent chapters, using Towers of Hanoi, chess, Nim and other games.

After this we look at natural language processing – referencing ELIZA as an example – followed by heuristics, pattern recognition and AI for robotics. Although much of this may seem outdated in this modern age of LLMs and neural networks, it’s important to realize that much of what we consider ‘bleeding edge’ today has its roots in AI research performed in the 1950s and 1960s. As [Timothy] rightfully states in the final chapter, there is no real limit to how far you can push this type of AI as long as you have more hardware and storage to throw at the problem. This is where we now got datacenters full of GPU-equipped systems churning through vector space calculations for the sake of today’s LLM & diffusion model take on ‘AI’.

Using a Commodore 64 to demonstrate the (lack of) validity of claims is not a new one, with recently a group of researchers using one of these breadbin marvels to run an Ising model with a tensor network and outperforming IBM’s quantum processor. As they say, just because it’s new and shiny doesn’t necessarily mean that it is actually better.

For fans of retro games, Pac-Man is nothing short of iconic—a game so loved it’s been ported to nearly every console imaginable. But the Atari 2600 version, released in 1982, left players scratching their heads – as laid out in a video by [Almost Something]. Atari had licensed Pac-Man to ride the wave of its arcade success, but the home version, programmed solely by [Todd Fry], missed the mark, turning an arcade icon into a surprising lesson in over-ambitious marketing.

Despite the hype, [Fry] faced an almost impossible task: translating Pac-Man’s detailed graphics and complex gameplay to the Atari’s limited 4 K cartridge with only 128 bytes of RAM. Atari’s strict limitations on black backgrounds and its choice to cut costs by sticking with a 4 K cartridge left the game barely recognizable. The famous pellet-chomping maze became simpler, colors were changed, and the iconic ghosts—reduced to single colors—flickered constantly. And then, Atari went all in, producing twelve million copies, betting on the success of universal appeal. In a twist, Pac-Man did sell in record numbers (over seven million copies) but still fell short of Atari’s expectations, leaving millions of unsold cartridges eventually dumped in a New Mexico landfill.

This debacle even kind of marked Atari’s 1983 decline. Still, Pac-Man survived the hiccup, evolving and outlasting its flawed adaptation on the 2600. If you’re interested in learning more about the ins and outs of game ports, check out the fantastic talk [Bob Hickman] gave during Supercon 2023.

When making a birthday cake a bit more personal, one can create a novelty themed confection appropriate for the lucky recipient. In the case of [Spencer Owen], who you may know as the creator of the RC2014 retrocomputing ecosystem, it was appropriate to have one of the little machines at work somewhere, so [peahen] did just that. The result is a cake in the shape of an IMSAI 8080 microcomputer, but it does more than just look the part. This is a working replica of the classic machine, powered as you might expect by an RC2014 sitting next to it.

The lights are a set of addressable LEDs, and the switches are made from appropriately colored sweets. Sadly the plan to make these capacitive touch switched failed as the wiring became buried in the icing, but the LEDs deserve a second look. They’re encased in translucent heatshrink sleeving which is embedded under a layer of white icing, which is translucent enough, but on top for the classic panel light look are a set of edible cake-maker’s jewels. Best of all while all except the electronics is edible, the front panel is robust enough to have been removed from the cake in one and thus will live on.

We rather like the idea of electronics meeting sugarcraft, because fondant is a surprisingly versatile medium that deserves attention much further than just confectionery. We remember it being a popular cheap way to experiment with 3D printing back at the dawn of open source printers, and it still has some potential. Meanwhile if you’ve not seen the RC2014 we reviewed its original version back in 2016, and since then it’s evolved to become an ecosystem in its own right.

If you’re passionate about signal processing and retro tech, you’ll want to check out the Createc SC 01, a quirky handheld oscilloscope that recently caught the eye of [Thomas Scherrer] from OZ2CPU Teardown. This device, cheekily dubbed a “signal computer,” promises to be both intriguing and, perhaps, frustrating. You can view [Thomas]’ original teardown video here.

This device is packed with buttons and a surprisingly retro aesthetic that can make even the most seasoned hacker feel nostalgic. With a sample rate of 20 MHz and a bandwidth of up to 10 MHz, it’s a digital oscilloscope with a twist. Users may find its setup challenging, thanks to a somewhat convoluted manual that boasts numerous errors. However, beneath the confusion lies the potential for creative exploration: this signal computer can analyse analog signals, perform calculations, and even store data.

Despite its quirks, the SC 01 is sure the experience. Imagine troubleshooting a circuit while grappling with its unpredictable user interface—an adventure in itself for those who like a techy challenge.

The Createc SC 01 is not just another tool; it’s an invitation to embrace the imperfections of vintage tech. If you enjoy the hands-on learning process and don’t shy away from a few hiccups, this device might be something you’ll enjoy. Hackaday featured an article on similar devices last year. Check out the full teardown video to see this fancy but quirky pocket oscilloscope in action.

Despite the rise of ARM processors in more and more computers from embedded systems to daily driver PCs, the x86 architecture maintains a stronghold in the computing space that won’t be going away anytime soon. One of the main drivers of this is its beachhead in industrial systems; the x86 architecture is backwards-compatible farther back than many of us have been alive and in situations where machines need to run for years with minimum downtime it’s good to know you can grab any x86 system off the shelf and it’ll largely work. This is also true for gaming, so if you’re like [Yeo Kheng Meng] and want to run games like DOOM natively on modern hardware it’s certainly possible, although there are a few catches.

This build goes into the design of a modern AMD Ryzen 5 desktop computer, with all of the components selected specifically for their use running software more than three decades old now. [Yeo Kheng Meng] is targeting DOS 6.22 as his operating system of choice, meaning that modern EFI motherboards won’t necessarily work. He’s turned to business class products as a solution for many of these issues, as motherboards targeting business and industrial customers often contain more support for antiquated hardware like PS/2 and parallel ports while still having modern amenities like DDR5 memory slots. PS/2 ports additionally are an indicator that the motherboard will supports older non-EFI boot modes (BIOS) and can potentially run DOS natively. Everything here can also run modern operating systems, since he isn’t building this system only to run DOS and retro games.

Beyond the motherboard choice, he’s also using a Soundblaster card for audio which is a design choice generally relegated to history, but still used in modern gaming by a dedicated group. There’s also a floppy drive running via a USB header adapter cable. Of course, there are a few problems running DOS and other era-appropriate software natively on such incomprehensibly fast hardware (by early 90s standards). Some video games were hard coded to the processor clock of the x86 process of the era, so increasing the clock speed orders of magnitude results in several playability issues. In emulators it’s easier to provide an artificially slow clock speed, but on real hardware this isn’t always possible. But [Yeo Kheng Meng] has done a lot to get this modern computer running older software like this. Another take we’ve seen for retro gaming on original hardware is this system which uses a brand-new 486 processor meant for use in industrial settings as well.

We have probably all been there: that sudden memory of playing a (video) game and the good memories associated with said memory. Yet how advisable is it to try and re-experience those nostalgic moments? That’s what [Matt] of the Techmoan YouTube channel decided to give a whirl when he ordered the Arcade1Up Pong 2 Player Countercade game system. This comes loaded with multiple variants of the Pong game, including Pong Doubles and Pong Sports, in addition to Warlords, Super Breakout and Tempest. This unit as the name suggests allows for head-to-head two-player gaming.

This kind of ‘countercade’ system is of course much smaller than arcade versions, but you would expect it to give the Pong clones which [Matt] played as a youngster a run for their money at least. Ultimately [Matt] – after some multiplayer games with the Ms. – concluded that this particular nostalgia itch was one that didn’t have to be scratched any more. While the small screen of this countercade system and clumsy interface didn’t help much, maybe Pong just isn’t the kind of game that has a place in 2024?

From our own point of view of having played Pong (and many other ‘old’ games) on a variety of old consoles at retro events & museums, it can still be a blast to play even just Pong against a random stranger at these places. Maybe the issue here is that nostalgia is more about the circumstances of the memory and less of the particular game or product in question. Much like playing Mario Kart 64 on that 20″ CRT TV with three buddies versus an online match in a modern Mario Kart. It’s just not the same vibe.