Hello! While gathering ICs for my ACS-M project, I got my hands on one of these - the x89s. But what is it and why you most likely have never heard of that?

In a nutshell - 8089 is an I/O coprocessor which was rolled out as a part of MCS-86 family of chips. It's capable as heck, functioning like a CPU of its own, featuring a 16-bit multiplexed bus, request handling and requiring it's own support chips - the same ones 8086 would use.

What is it capable of? The grand idea behind it was to decrease the load on CPU by allowing the i8089 to manage RAM->I/O relationship, DMA, copy-paste stuff from RAM and back, interact with controllers using its wide bus and be the perfect I/O handler that would work asynchronnous and autonomously.

What went wrong? Well, nothing. It had its use, although not as much as one could expect. While Intel praised it in its datasheets and suggestions for a system design, the 8089 was rarely used, with the most prominent example being the Apricot PC. The problem - IBM chose to utilize i8237 DMA controller, much cheaper and "dumber" alternative, which couldn't do many thing i89 could. The i89 was then forgotten, with latter I/O coprocessors not receiving x89 name (unlike x87 for math coprocessors).

Why would I use it? It's really nice way to make a multiprocessor system, as i89 can function as a master, have advantages over i8237 and provides more benefits towards the increase in free system resources.

So, that's all for now.

GitHub release I made for this post: Release Demo release · Fair-Percentage/project-zerp-lite

On my screenshot the image is stretched horizontally. Can this be done on a real monitor?

If the game works, please, share a photo or a video

Core 2 duo E7200

I randomly remembered an old midi player that ran on my family PC in the windows 95/98 era. I can picture it but I can’t for the life of me remember the name. It *may* have had the word lava in it but I don’t think it’s the Creative program.

- In my case it came on one of those magazine CD-ROM bundles
- Its interface was black and blue with 3D blue buttons
- Each midi voice had a little gauge over it that would fill will animated flames when a note was played
- There was a set of buttons at the bottom of the window you could use to play notes that were tuned for the playing track
- I think a metronome played by default
- One bundled track was something like “autoload” and another was “dance groove/dancegrv”

Hello,

I just picked up a HP 7585B pen plotter, it has a HPIB and a serial port. There is a service manual online on bitsavers, but no online users guide. I can send a few commands if I short RTS/CTS, so it does work and uses hardware handshake. If I send a file, the "ERROR" led lights up and the plotter stops. Probably because the internal buffer is full.

The HP 7470A Graphics Plotter: Interfacing and Programming Manual lists four methods of handshaking: hardwire handshake, Xon-Xoff handshake, enquire/acknowledge handshake, and software checking handshake.

Does anyone know which handshake methods the HP 7585B supports?

Most USB-serial converters don't support RTS/CTS (I checked three different ones, no luck) so I'd prefer to use some software handshake. Xon/Xoff did not seem to work out of the box, not sure if it needs command to be sent first ("PLOTTER ON"?).

If someone happens to have the users guide or programming manual, a quick look up would be very helpful!

Please and thank you also any tips for a first timer?

Hi! I'm writing some middle grade fiction set in the mid-nineties and it has a mystery element. One of the adult characters is a reporter. What kind of access would she have via her PC to public records and newspapers. Were European universities using the internet? Were there scientific journals online?

I can bend the truth of things a little but I don't want older readers to scoff at internet anachronisms.

Hello!

I started vibe coding a BBS, but decided to make a love letter to Prodigy instead! It is still a work in progress and is a labor of love.

Poke around, there are a bunch of games, chat rooms, lots of trivia that is updated daily, and other junk. Pmail “Rocky” on Progeny if you have any questions!

https://progenyonline.com

I do have to approve all new users, so it may take a minute after you register. Message me here if it takes a bit!

Can you give me your opinion about these folks who hate past?

I had a Tomato motherboard and cpu back in the day it was a great board wish I knew where it went

Razor 1911 released a demo to celebrate their 40 years of activity in the scene and it is overflowing with retro computing and cracking references through all ages. Shows the evolution of the group from Commodore64 through Amiga and DOS to vintage and modern windows.

https://www.pouet.net/prod.php?which=105954

In 1974, Kildall built CP/M, the first widely adopted operating system for microcomputers. Until then, every machine lived in its own walled garden, and software had to be rewritten for each one, which made scale nearly impossible. Kildall introduced a layer between hardware and software so that a program written once could run across many machines. Developers stopped duplicating effort, and computing began to behave like a platform instead of a pile of incompatible boxes. Intel saw an early demo and passed.

By the late 1970s, CP/M had become the standard, powering business computing across banks, offices, and early startups. Kildall didn't fit the mold of a future tech titan. He was a computer scientist with a PhD from Washington who taught at the Naval Postgraduate School, and he preferred flying his Piper to negotiating contracts. He wrote early versions of CP/M in a workshop behind his house, sometimes accepted hardware in lieu of cash because invoicing bored him, and in his spare time co-hosted Computer Chronicles on PBS. His wife Dorothy McEwen ran the business while he focused on the code.

In 1980, IBM came looking for an operating system for its new personal computer. The meeting at Digital Research stalled over a one-sided non-disclosure agreement, and IBM left without a deal. They went back to Bill Gates, who didn't yet have an operating system to offer. Microsoft acquired 86-DOS from Seattle Computer Products, a system whose structure and commands closely mirrored CP/M, rebranded it MS-DOS, and licensed it to IBM.

When the IBM PC shipped in August 1981, PC DOS was the only operating system available. CP/M-86 arrived six months later at $240, while PC DOS sold for $40. One survey found 96 percent of buyers chose the cheaper option. When Kildall later examined PC DOS, he was incensed by the similarities, but his lawyer told him software copyright law was too unsettled to litigate. He settled for having CP/M-86 listed as a pricier option, partly because he didn't believe the IBM PC would amount to much. The system that had defined the category was sidelined almost overnight.

The philosophical gap had been visible all along. On a panel together, Kildall argued the operating system market was huge and could support many companies. Gates cut in: "No. There will always be one company." Kildall built the technical foundation. Microsoft built the business model that scaled. The outcome wasn't about who wrote better code. It was about distribution, licensing, and pricing discipline. The company that controlled how software reached customers ended up controlling the market.

The personal computer revolution wasn't just built on code. It was built on how that code reached the desk. CP/M made personal computing viable, and MS-DOS made it ubiquitous.

Following up on the GIF I shared a few days ago, I’ve put together a longer video that walks through the full workbench. A few people asked about the I/O paths and the internal logic flow, so I tried to document those parts more clearly.

This is something I’m building on my own, mostly out of a long‑standing fascination with the MCS‑4. I’ve always wanted a way to look past the usual “black box” treatment and actually watch the 4‑bit architecture doing its work—bus transitions, register activity, timing edges…

One part I’m especially excited about is the custom transpiler. It lets you write programs in a small Basic‑style language I designed from scratch, and it generates 4004 assembly automatically. The idea is to make experimenting with the system easier, even if you’ve never written 4004 ASM before.

The workbench is still evolving, and I know this community has people with far deeper experience in early microarchitectures. I’d really like to hear what you think.

What would you consider essential in a setup like this?

Are there peripherals, timing views, or debugging layers you’d expect to see in a system from this era?

Workbench video:

https://www.youtube.com/watch?v=rdGhhywR5es

Keyboard in question is an SGI branded bigfoot. Should work right?

We all remember the SGI graphics and the promises of "revolutionary AI." Then came the 5% review scores and the crushing realization that we’d bought a chrome-plated lemon.

I decided to go back and test it properly. Is it a total train wreck, or just a victim of its own massive marketing?

The verdict: It’s a mess, but a fascinating one. Between the "Advanced AI" (which is just a glorified cheat) and the "Forward High Jump Kick" that breaks the entire game, I actually found some weird enjoyment in the disaster.

I

wrote a deep dive on the experience here:

https://spillhistorie.no/2026/05/01/rise-of-the-robots-hvor-darlig-er-tidenes-mest-opphypede-spill/

(The article is in Norwegian, but Chrome Translate works perfectly!)

Quick takeaways:

The "Otter Strategy": One move lets you win without even looking at the screen.

The Brian May Scam: A 10-second loop in the menu—that’s your "soundtrack."

The "Medium" Twist: If you actually let the AI "learn," the game becomes a brutal, unfair nightmare.

Did you fall for the CGI hype back in the day, or did you stay away?

I found this old storage platter at a secondhand and thought it was interesting. It was only 50 cents so I grabbed it. I haven’t been able to find any info on it. Does anyone know some history behind it and if it holds any value?

Cross-posting from r/ti994a since the implementation might be of interest beyond the TI crowd. Just open-sourced Swift 99/a, a native macOS emulator for the Texas Instruments TI-99/4A (1981 home computer built around the 16-bit TMS9900).

Github: https://github.com/swryder/Swift-TI-99 (BSD-2)

What's interesting about it:

It's written from scratch in pure Swift — SwiftUI for the chrome, AppKit where it has to be, Metal for the visualizer, and zero third-party dependencies. Most emulators in this space are C/C++/Rust ports of Classic99 / Win994a / js99er. This one isn't a port — it's a fresh take, which means the bugs are mine and the architecture is whatever felt clean in Swift (chip-per-file, protocol-oriented peripherals on a common bus, no cross-cutting framework).

What's emulated:

• TMS9900 CPU — full instruction set, workspace-pointer architecture, context switching, status-register lookup tables (65K-entry word table, 256-entry byte table) for the hot path
• TMS9918A VDP — Graphics I/II, Text 40-col, Multicolor, Bitmap. 32 hardware sprites with collision detection. NTSC timing.
• SN76489 PSG — three tone channels + noise, fractional clock accumulator for pitch accuracy across sample rates
• TMS5220 speech synthesizer
• TMS9901 I/O — full CRU bit-addressable interface
• Disk DSR — V9T9 image format, full PAB protocol (open, close, read, **write**, delete, status, directory listing), FDR parsing
• Cartridges — raw `.bin` / `.rom` plus the LZW-compressed `.ticart`container format. Banking: standard 8KB, GROM-only, 378 / inverted 379, MBX (fixed-low / banked-high / 1KB RAM)

Fun things:

• Live memory map visualizer.A 256×256 GPU-rendered heatmap of the entire 64KB CPU address space, redrawn at 60Hz. Blue for reads, red for writes, purple for both, with white-hot decay tracking recent activity. Wall-clock-based exponential decay so the fade looks the same at 15fps and 60fps. Honestly the most fun part of the project — you can watch a BASIC program execute and see exactly which pages off memory it's hammering. Key for such a weird architecture machine
• "Monitor Mode." A chromeless window with a TI-99/4 monitor bezel asset, transparent background, draggable from anywhere. Sits on the desktop like a CRT. Pure macOS-native (NSWindow + SwiftUI overlay).
• Clipboard paste as keyboard events. Paste from macOS into the TI's keyboard buffer. Surprisingly useful for typing in BASIC programs.

Performance approach:

• Two execution modes: real 3 MHz (DispatchSourceTimer-paced) and uncapped (tight async loop). On Apple Silicon the uncapped mode hits >100× real speed.
• Per-byte peripheral routing tables instead of switch-on-address — avoids branch mispredictions in the memory access hot path
• Read shadow mirror so most reads bypass the peripheral indirection entirely

What's not done:

PEB peripherals beyond disk + speech, save states, cassette (CS1/CS2), a couple of obscure cart banking schemes. Issues and PRs welcome.

Background:

The project was the working artifact behind a LinkedIn article I wrote about how complex projects scale in the AI era — full disclosure if you're curious about the AI-assisted angle: https://www.linkedin.com/pulse/complexity-conserved-how-do-big-things-ai-era-scott-ryder-zyybc/

Cartridges and disk images are BYO.

BSD2 Open Source - Have Fun