Homebrew CPU

Me being a caveman who believes that technology is a hammer that still can be used to drive nails into building materials instead of our own heads, I'm longing for an Intermesh of simple networked 8-bit machines running on vanilla (no ARM core bonuses) FPGAs, with CPUs simple enough to be predictable and understood not by a select few superhumans in the world, but by a critical mass of people, and communication protocols built from scratch with privacy and security in mind, so that such device could represent a social node: here's some info that I chose to make public, and there's my protected data. A single pedestrian FPGA could host a swarm of such tiny CPUs, each dedicated to a single task or security domain: a CPU to talk to shared filesystem, a CPU to talk to the private one, one more to process input, one to Tx/Rx bytes over the wire etc..

Or, if that is too complex, there could just be a bunch of breadboarded ICs capable of networking. There actually are real-world examples of such machines exposed via telnet, e.g. http://www.homebrewcpu.com

And all the performance beasts, while surely indispensable, could just enjoy their air-gapped solitude. Are there any massively parallel supercomputing tasks whose results couldn't be summarized and reduced to mere text, which is not too hard to move over the airgap manually?

This project was inspired by Magic-1[0]. The construction is entertaining to read[1]. And it is used currently as a web server[2]. What a very fantastic project!

Quoting from the project history:

In the beginning....

Magic-1 really began during a lunchtime discussion with Ken Sumrall at Vito's Pizza in Sunnyvale, CA sometime in the Spring of 2001. I was complaining to Ken about how as a compiler writer I was woefully ignorant about how CPU hardware really worked. I hadn't taken any electronics classes in college, and was only vaguely aware of what transistors, resistors and capacitors were. Ken recalled an old series of magazine articles by Forrest Mims on building a very simple CPU from TTL parts, and suggested I read it. Over the next few weeks, I tracked down those articles, as well as Mims' "Understanding Digital Computers" and a textbook by Albert Paul Malvino, "Digital Computer Electronics."

I read them all, and when I next had lunch with Ken at Vito's I reported back that it all seemed much clearer now - so much so that I thought I could even build a CPU myself. Then Ken said, "well, why don't you?".

Why not, indeed?

And so the Magic-1 project began.

[0] - http://www.homebrewcpu.com/

[1] - http://www.homebrewcpu.com/construction.htm

[2] - http://www.magic-1.org/

The mega processor is one of my all-time favorite computers, along with the Magic-1 https://homebrewcpu.com/

The megaprocessor is just absolutely wonderful in how it bridges from 'here is a transistor, it lights an LED' to 'here is a computer, it plays tetris'. I always struggled to unwind the layers of abstraction in a modern computer from atoms in the CPU to running python, but being able to just look at a bunch of literal transistors (with LEDs on each gate!) wired up playing tetris shows how a computer really works in such a profound and awe inspiring fashion.

Magic-1 is sort of the next level higher complexity, where it is made out of very simple TTL (most complicated chip function is the ALU--a circuit I had to build as an EE undergrad out of or- and and- gates) and it hosts a webpage. It currently seems to be down, but you can see it on the wayback machine
https://web.archive.org/web/20210815180101/http://www.magic-1.org/

I will never forget when I came across that site and realized that I was interacting with a wirewrapped pile of ram and nor gates over the internet. There was even a time when you could telnet in and play some retro text-based adventure games, To this day, the only time I have played Adventure was on Magic-1.

>The Ena.Computer is designed using 550 double triode 6N3P electron-tubes, all configured as identical 5 input NOR gates. Registers and counters are built from these single NOR gates and combined into master/slave D type flip flops, an 8 bit ALU, and all latches and buffers.

In my computer science program, we had an old school prof who insisted we build a virtual CPU using only fundamental components. No VHDL for us! We wanted a JK flip flop? Here are the logic gates. Wire them up baby. The only thing that came for free were the logic gates, a clock, and probes. Some students complained about it; and I get it, it was a very old-school way of doing things. But I can say that I intimately understood my 5-staged pipeline CPU, because I designed it from the ground up, and spent hours wiring every component. I also had plenty of time cursing myself for some stupid design decisions I made along the way. The only thing that might have made it better if we were tasked with actually building it out in actual hardware. I'm a fan of those homebrew cpu's out there. Maybe not practical from computing perspective any more, but sooo cool.

http://homebrewcpu.com/

https://hackaday.io/project/178826-pineapple-one

Create a piss-poor barebones compiler (compiler A) by hand (literally, if possible. punchcards would allow you to hand-verify the contents of the program in a way that is not susceptible to Thompson's attack (there is no risk that your eyes were built with a compromised compiler)) that suffices to compile a compiler that you want to verify (compiler B). Compiler A should to run on hardware that you can trust (need not be x86).

(= ((a-binary b-source) b-source) b-binary)

If you trust a-binary, and you trust b-source, then if that returns true you should be able to trust anything created with b-binary. (a-binary b-source) will not equal b-binary, but ((a-binary b-source) b-source) should.

If the hardware is not executing binaries as described, then all bets are off. Compiler A could, in theory, be build and run on a homebrew CPU (http://www.homebrewcpu.com/), but if you are putting that much effort into this, this better be your hobby...

Thanks! I don't remember if I've seen it before.

In case it's down for others: https://web.archive.org/web/20250221070009/http://magic-1.org/

"This web page is being served by a completely home-built computer: Bill Buzbee's Magic-1 HomebrewCPU. Magic-1 doesn't use an off-the-shelf CPU. Instead, its custom CPU is built out of ~200 74 series TTL chips."

"Magic-1 is running a new port of Minix 2.0.4, compiled with a retargeted LCC portable C compiler. The physical connection to the internet is done using a native interface based on Wiznet's w5300 TCP/IP stack."

While I hate to condone using TTL rather than CMOS, this is extremely cool!

The CPU is documented at https://homebrewcpu.com/. Unfortunately the TCP/IP information was only posted on Google Plus, which has now been memory-holed by Google.

There's a clone by Aidil Jazmi documented at https://www.aidilj.com/homemadecpu/.