First Transistor Computer Reborn

September 21, 2025 by 15 Comments

Ok, we’ll admit it. If you asked us what the first transistorized computer was, we would have guessed it was the TC from the University of Manchester. After all, Dr. Wilkes and company were at the forefront and had built Baby and EDSAC, which, of course, didn’t use transistors. To be clear, we would have been guessing, but what we didn’t know at all was that the TC, with its magnetic drums and transistors in 1955, had a second life as a commercial product from Metropolitan-Vickers, called the Metrovick 950. [Nina Kalinina] has a simulator inspired by the old machine.

The code is in Python, and you can find several programs to run on the faux machine, including the venerable lunar lander. If you haven’t heard of the Metrovick, don’t feel bad. Oral histories say that only six or seven were ever built, and they were used internally within the company.

Continue reading “First Transistor Computer Reborn” →

A Serial Mouse For A Homebrew 8-bit Computer

September 21, 2025 by 2 Comments

[Too Many Wires] has a custom computer he’s building. He wanted a mouse, but USB is a bit of a stretch for the fledgling computer. We might have opted for PS/2, but he went for something even older: a serial mouse connected with a DE-9 (colloquially, a DB-9). Check it out in his recent video update on the project below.

Don’t remember serial mice? They were very common many years ago, and apparently, you can still buy new ones, which makes you wonder what people are doing with them. If you are an old hand at serial, you’ll immediately know why he couldn’t get it to work at first. If you haven’t worked with RS-232 gear before, you’ll learn a lot.

The protocol is simple enough, and you can read the code or find plenty of old documents. He’s using a UART chip, which offloads the CPU. However, the PS/2 mice are very easy to work with directly, and you could skip the +/- 12V RS-232 and other issues.

Either way, however, using an RS-232 or PS/2 mouse in a project is relatively straightforward. You might not think you need a mouse, but don’t forget, they are really accurate two-axis sensors. An optical mouse on a motion table, for example, could be worth something.

The computer is based on [Ben Eater]’s design, if you want more details on that. Can’t decide between RS-232 and PS/2? You don’t have to.

Continue reading “A Serial Mouse For A Homebrew 8-bit Computer” →

Computer Has One Instruction, Many Transistors

September 20, 2025 by 22 Comments

There’s always some debate around what style of architecture is best for certain computing applications, with some on the RISC side citing performance per watt and some on the CISC side citing performance per line of code. But when looking at instruction sets it’s actually possible to eliminate every instruction except one and still have a working, Turing-complete computer. This instruction is called subleq or “subtract and branch if less-than or equal to zero“. [Michael] has built a computer that does this out of discrete components from scratch.

We’ll save a lot of the details of the computer science for [Michael] or others to explain, but at its core this is a computer running with a 1 kHz clock with around 700 transistors total. Since the goal of a single-instruction computer like this is simplicity, the tradeoff is that many more instructions need to be executed for equivalent operations. For this computer it takes six clock cycles to execute one instruction, for a total of about 170 instructions per second. [Michael] also created an assembler for this computer, so with an LCD screen connected and mapped to memory he can write and execute a simple “hello world” program just like any other computer.

[Michael] does note that since he was building this from Logisim directly he doesn’t have a circuit schematic, but due to some intermittent wiring issues might have something in the future if he decides to make PCBs for this instead of using wire on a cardboard substrate. There’s plenty of other information on his GitHub page though. It’s a unique project that gets to the core of what’s truly needed for a working computer. There are a few programming languages out there that are built on a similar idea.

Continue reading “Computer Has One Instruction, Many Transistors” →

A photo of the internal wiring.

Imagining The CPS-1: An Early 70s 4-bit Microcomputer From Canada

September 19, 2025 by 4 Comments

[Michael Gardi] wrote in to let us know about his project: CPS-1: Imagining An Early 70s 4-bit Microcomputer.

The CPS-1 was the first Canadian microprocessor-based computer. It was built by Microsystems International Ltd. (MIL) in Ottawa between 1972 and 1973 and it is unknown how many were made and in what configurations. The CPS-1 supported a 12-bit address bus and a 4-bit data bus. MIL also developed the supporting hardware including RAM. The processor was called the MIL 7114.

[Michael] worked in collaboration with [Zbigniew Stachniak] from York University Computer Museum. [Zbigniew] had developed a MIL CPS-1 Emulator and [Michael]’s job was to implement a front panel hardware interface for the emulator which runs on a Raspberry Pi. The only complication: there are no remaining CPS-1 computers, and no known photographs, so no one can say for sure what a real front panel might have looked like!

With a bit of guess work and 3D printing, as well as some inspiration from contemporaneous hardware such as the DEC PDP-11, [Michael] came up with an implementation. He used an IO extender HAT which adds 32 IO pins to the existing Pi GPIO pins that are accessible via an 3-wire I2C interface. This was enough hardware to support the 26 switches and 29 LEDs on the panel. There’s a brief demo of the custom printed switches in the video embedded below.

If you’re interested in old school 4-bit tech you might also like to check out 4-bit Single Board Computer Based On The Intel 4004 Microprocessor.

Continue reading “Imagining The CPS-1: An Early 70s 4-bit Microcomputer From Canada” →

Photo of Microtronic 2090

The Microtronic Phoenix Computer System

September 15, 2025 by 4 Comments

A team of hackers, [Jason T. Jacques], [Decle], and [Michael A. Wessel], have collaborated to deliver the Microtronic Phoenix Computer System.

In 1981 the Busch 2090 Microtronic Computer System was released. It had a 4-bit Texas Instruments TMS1600 microcontroller, ran at 500 kHz, and had 576 bytes of RAM and 4,096 bytes of ROM. The Microtronic Phoenix computer system is a Microtronic emulator. It can run the original firmware from 1981.

Between them the team members developed the firmware ROM dumping technology, created a TMS1xxx disassembler and emulator, prototyped the hardware, developed an Arduino-based re-implementation of the Microtronic, designed the PCB, and integrated the software.

Unlike previous hardware emulators, the Phoenix emulator is the first emulator that is not only a re-implementation of the Microtronic, but actually runs the original TMS1600 firmware. This wasn’t possible until the team could successfully dump the original ROM, an activity that proved challenging, but they got there in the end! If you’re interested in the gory technical details those are here: Disassembling the Microtronic 2090, and here: Microtronic Firmware ROM Archaeology. Continue reading “The Microtronic Phoenix Computer System” →

A Breadboard Computer In Three Chips

September 12, 2025 by 4 Comments

Building a computer on a breadboard is a seminal project for many builders, but it can become complicated quite quickly, not to mention that all the parts needed for a computer are being placed on a medium which often lends itself to loose wires and other hardware bugs. [3DSage] has a working breadboard computer that is as simple as it can possibly be, putting it together piece by piece to show exactly what’s needed to get a computer which can count, access memory, and even perform basic mathematical operations.

The first step for any computer is to build a clock, and in this case it’s being provided by a 555 timer which is configured to provide an adjustable time standard and which steps through the clock pulses when a button is pressed. The next piece is a four-bit counter and a memory chip, which lets the computer read and write data. A set of DIP switches allows a user to write data to memory, and by using the last three bits of the data as opcodes, the computer can reset, halt, and jump to various points in a simple program.

Although these three chips make it possible to perform basic programming, [3DSage] takes this a bit further in his video by demonstrating some other simple programs, such as one which can play music or behave as an alarm clock. He also shows how to use a fourth chip in the form of a binary adder to perform some basic math, and then packages it all into a retro-styled computer kit. Of course you can take these principles and build them out as far as they will go, like this full 8-bit computer built on a breadboard or even this breadboard computer that hosts a 486.

Continue reading “A Breadboard Computer In Three Chips” →

Hands holding a TI-99/4A.

How The TI-99/4A Home Computer Worked

September 11, 2025 by 56 Comments

Over on YouTube [The 8-Bit Guy] shows us how the TI-99/4A home computer worked.

[The 8-Bit Guy] runs us through this odd 16-bit home computer from back in the 1980s, starting with a mention of the mysterious extra “space” key on its antiquated keyboard. The port on the side is for two joysticks which share a bus, but you can find boards for compatibility with “newer” hardware, particularly the Atari-style joysticks which are easier to find. The AV port on the back is an old 5-pin DIN such as was typical from Commodore and Atari at the time (also there is a headphone port on the front). The other DB9 port on the back of the device is the port for the cassette interface.

The main cartridge interface is on the front right of the machine, and there’s a smaller expansion socket on the right hand side. The front interface is for loading software (on cartridges) and the side interface is for peripherals. The system boots to a now famous “press any key” prompt. (We know what you’re thinking: “where’s the any key!?” Thanks Homer.)

Continue reading “How The TI-99/4A Home Computer Worked” →