Ben Eater Rebuilds 8-Bit Breadboard Computer on Camera from Scratch

8-bit computer update — Ben Eater

Ben Eater

Anyone can understand computer architecture at a fundamental level without prior electronics training by methodically assembling hardware modules and debugging circuits from first principles.

AI-assisted summary of 8-bit computer update — original source. Check the original for full context.

Source published:

Key ideas

  • Ben Eater announced a complete rebuild of his breadboard 8-bit computer from scratch on camera, teaching every concept from first principles without formal prior schematics. (3:24)
  • The computer is grounded in Albert Paul Malvino's SAP-1 architecture from 'Digital Computer Electronics', expanded with 16 bytes of RAM, a decimal display, and added instructions like store and conditional jumps. (0:53)
  • The tutorial series aims for a cadence of at least one video per week, starting with a 555-timer-based clock module featuring variable speed and manual stepping. (4:02)

Detailed notes

## Background Published on YouTube by Ben Eater on March 9, 2016, this video provides an update on his plans to build another 8-bit breadboard computer from scratch and document the entire process on camera. The description highlights kit availability for viewers who want to build along at home and links to his Patreon page.

## TL;DR Addressing frequent viewer requests for schematics, Ben Eater explains that his 8-bit breadboard computer was built modularly without a formal blueprint, adapting Albert Paul Malvino's SAP-1 architecture with custom upgrades such as a decimal display and extra instructions. To properly document the build, Eater announces a comprehensive reconstruction series where he will assemble another computer from scratch, teaching digital logic from first principles at a pace of roughly one video per week. He reassures viewers that anyone can succeed with patience and systematic debugging, before previewing the first project: a flexible 555-timer-based master clock with adjustable speeds and manual single-stepping.

## Atmosphere & style The presentation is calm, earnest, and encouraging, marked by Ben's transparent admission that his sprawling breadboard masterpiece never had a formal master schematic. His pedagogical style is grounded and accessible, stripping away intimidating academic pretense to frame complex digital electronics as an approachable, step-by-step craft. The experience feels like an inviting open-door invitation into an engineer's workbench, pairing patient explanations with the satisfying tactile click of switches and slowing clock pulses.

## Bulletin - [03:24](https://www.youtube.com/watch?v=HyznrdDSSGM&t=204s) Ben Eater announced a complete rebuild of his breadboard 8-bit computer from scratch on camera, teaching every concept from first principles without formal prior schematics. - [00:53](https://www.youtube.com/watch?v=HyznrdDSSGM&t=53s) The computer is grounded in Albert Paul Malvino's SAP-1 architecture from 'Digital Computer Electronics', expanded with 16 bytes of RAM, a decimal display, and added instructions like store and conditional jumps. - [04:02](https://www.youtube.com/watch?v=HyznrdDSSGM&t=242s) The tutorial series aims for a cadence of at least one video per week, starting with a 555-timer-based clock module featuring variable speed and manual stepping.

## Key takeaways - [00:16](https://www.youtube.com/watch?v=HyznrdDSSGM&t=16s) The original breadboard computer was built modularly without a complete master schematic drawn beforehand. - [00:53](https://www.youtube.com/watch?v=HyznrdDSSGM&t=53s) The design adapts the SAP-1 ('Simple As Possible-1') architecture from Albert Paul Malvino's textbook 'Digital Computer Electronics'. - [01:19](https://www.youtube.com/watch?v=HyznrdDSSGM&t=79s) The machine utilizes 16 bytes of RAM instead of the programmable read-only memory described in the original SAP-1 design. - [01:50](https://www.youtube.com/watch?v=HyznrdDSSGM&t=110s) The stock SAP-1 instruction set of five commands was expanded to include immediate load, store (STA), unconditional jump, and conditional jump on carry. - [01:45](https://www.youtube.com/watch?v=HyznrdDSSGM&t=105s) Hardware upgrades beyond the baseline SAP-1 include a decimal output readout replacing the raw binary display. - [01:33](https://www.youtube.com/watch?v=HyznrdDSSGM&t=93s) Yellow wiring across the breadboards routes control signals dispatched by the control unit to synchronize all modules. - [03:24](https://www.youtube.com/watch?v=HyznrdDSSGM&t=204s) The upcoming video series will reconstruct the entire machine completely from scratch, emphasizing first-principles explanations. - [03:56](https://www.youtube.com/watch?v=HyznrdDSSGM&t=236s) Completing the reconstruction series is projected to take at least several months, targeting a release pace of one video per week. - [04:17](https://www.youtube.com/watch?v=HyznrdDSSGM&t=257s) Building the computer requires no formal electronics background, relying primarily on neat wiring and systematic debugging. - [05:06](https://www.youtube.com/watch?v=HyznrdDSSGM&t=306s) The first module to be constructed is the master clock circuit built around 555 timer integrated circuits. - [05:31](https://www.youtube.com/watch?v=HyznrdDSSGM&t=331s) The master clock integrates potentiometer-driven variable speed control alongside a halt mode and a manual single-step button for debugging.

## Detailed walkthrough ### [00:00](https://www.youtube.com/watch?v=HyznrdDSSGM&t=0s) Building Without Schematics: The SAP-1 Model and Custom Enhancements

Ever since Ben Eater uploaded videos of his breadboard-based 8-bit programmable computer, viewers have repeatedly asked for schematics or a step-by-step tutorial. Ben confesses that he never actually drafted a complete schematic before assembling the machine. Because the design is fundamentally modular, he was able to build, test, and experiment with one distinct module at a time before integrating them. He explains that it was only when bringing all the sections together that he had to be more deliberate about the full system's operation.

For the foundational blueprint, Eater followed the architecture presented in the textbook *Digital Computer Electronics* by Albert Paul Malvino. Though out of print, he strongly recommends seeking out a used copy. The book introduces simplified architectures, most notably the SAP-1 ("Simple As Possible-1"), designed to demonstrate the core principles of computer operations without unnecessary complexity. Eater’s computer incorporates all the primary elements of the SAP-1: a program counter, a memory address register (MAR), 16 bytes of memory (RAM in Eater's build, where Malvino used programmable read-only memory), an instruction register, a control unit, an accumulator (A register), a B register, an arithmetic logic unit (ALU) limited strictly to addition and subtraction, and an output display. The sprawling mass of yellow wires running across the breadboards carries control signals dispatched from the control unit to orchestrate the entire machine.

Eater also added several hardware and instruction set enhancements over the book's baseline design. Where Malvino's SAP-1 featured a binary output, Eater incorporated a decimal display. In terms of software capabilities, the textbook only provided five instructions: load accumulator (`LDA`), add (`ADD`), subtract (`SUB`), output (`OUT`), and halt (`HLT`). Eater extended this by adding an immediate load command to save memory, a store instruction (`STA`) to write the accumulator back into RAM, an unconditional jump, and a conditional jump that triggers on an addition overflow carry bit. Regarding his lack of formal blueprints, Ben admits: “The answer is, believe it or not, I actually don't have schematics for this thing, I never sat down and drew out a full schematic.”

```mermaid flowchart TD accTitle: SAP-1 Architecture with Eater Enhancements accDescr: High-level overview of the 8-bit computer architecture based on SAP-1 and modified by Ben Eater.

subgraph MemoryControl ["Control & Addressing"] PC["Program Counter"] MAR["Memory Address Register"] RAM["16 Bytes RAM"] IR["Instruction Register"] CU["Control Unit\n(Yellow Signal Wires)"] end

subgraph Datapath ["ALU & Registers"] RegA["Accumulator (A Register)"] RegB["B Register"] ALU["ALU\n(Add & Subtract)"] end

subgraph OutputSection ["Output & Peripherals"] OutReg["Output Register"] Disp["Decimal Display\n(Enhancement)"] end

PC --> MAR MAR --> RAM RAM --> IR IR --> CU CU -.->|"Control Signals"| PC CU -.->|"Control Signals"| RAM CU -.->|"Control Signals"| RegA CU -.->|"Control Signals"| ALU CU -.->|"Control Signals"| OutReg

RAM <--> RegA RegA --> ALU RegB --> ALU ALU --> RegA RegA --> OutReg OutReg --> Disp ```

- **Reference material:** *Digital Computer Electronics* by Albert Paul Malvino (SAP-1 architecture). - **Core memory size:** 16 bytes. - **Stock SAP-1 instructions:** Load A (`LDA`), Add (`ADD`), Subtract (`SUB`), Output (`OUT`), Halt (`HLT`). - **Eater's instruction set additions:** Load immediate, Store A (`STA`), Unconditional Jump (`JMP`), Conditional Jump on Carry (`JC`). - **Display upgrade:** Converted Malvino's raw binary output display into a decimal readout.

---

[03:24](https://www.youtube.com/watch?v=HyznrdDSSGM&t=204s) The Reconstruction Series Plan and First Principles

To address the requests for guides and schematics, Ben announces a project to reconstruct an entire copy of the computer completely from scratch on camera. His pedagogical commitment is to teach every single concept from first principles so that viewers are never forced to accept anything blindly. However, because of his limited free time and the methodical pace required to detail every underlying mechanism, the project will require a significant amount of time—at least a few months, and likely longer. He sets a baseline personal goal of releasing at least one video per week.

Ben firmly believes that anyone can successfully replicate this build, regardless of whether they have a background in electronics, provided they possess the patience to wire each lead neatly and the perseverance to debug inevitable errors. “I'm convinced that anyone can build this and really understand at a very deep level, how a computer works, by building this,” Ben states, emphasizing his desire to see viewers build and perhaps even expand upon the system.

- **Production goal:** Publish at least one video per week. - **Project scope:** A complete, breadboard-by-breadboard reconstruction filmed from scratch. - **Teaching philosophy:** Ground every design decision in first principles without relying on unexplained shortcuts. - **Prerequisites:** No prior electronics experience needed; requires only careful wiring habits and systematic debugging.

---

[05:06](https://www.youtube.com/watch?v=HyznrdDSSGM&t=306s) The Next Step: Variable 555-Based Clock Module

The series will begin with the design and construction of the master clock circuit, which coordinates the timing and operational states across all other functional units. Ben notes that he will be traveling over the coming week, meaning the clock video will debut in roughly two weeks.

The clock unit is engineered around 555 timer ICs configured for several distinct operational roles. Rather than remaining locked at a static frequency, the clock features a variable speed potentiometer—which Ben demonstrates by noticeably slowing down the execution speed of the entire machine—as well as a halt switch. Once halted, the user can pulse a manual single-step button, advancing the machine one clock cycle at a time. This manual stepping capability is vital for diagnosing errors, as troubleshooting faulty connections is an unavoidable phase of assembling the computer. Concluding the update, Eater encourages viewers to like, subscribe, and share the project, explaining that community interest and feedback serve as his primary motivation to keep creating the videos.

- **Upcoming build focus:** The master system clock. - **Key active components:** Multiple 555 timer integrated circuits. - **Clock operating modes:** - Adjustable continuous frequency (variable speed control via potentiometer). - Full stop / halt. - Manual single-step pulsing for cycle-by-cycle hardware debugging. - **Release timeframe:** Video launch expected in approximately two weeks following travel.

## Notable quotes > [03:24](https://www.youtube.com/watch?v=HyznrdDSSGM&t=204s) I'm convinced that anyone can build this and really understand at a very deep level, how a computer works, by building this — Ben Eater

## Mentioned Ben Eater, Albert Paul Malvino, Digital Computer Electronics, SAP-1, 555 timer IC, Patreon, YouTube

## Video description An update on my plans to build another 8-bit computer from scratch and make videos of the whole process! Buy a kit and build your own! https://eater.net/8bit/kits

Support me on Patreon: https://www.patreon.com/beneater

[Source](https://www.youtube.com/watch?v=HyznrdDSSGM)

Reading summary

Ben Eater announces a video series to rebuild his modular 8-bit breadboard computer from scratch, teaching digital electronics from first principles after initially assembling the machine without formal schematics. Adapting and Expanding Malvino's SAP-1 Architecture (0:00) Eater assembled his 8-bit computer modularly without drawing a comprehensive schematic in advance, testing individual units before integrating them. The foundational architecture comes from the Simple As Possible-1 (SAP-1) model in Albert Paul Malvino's textbook Digital Computer Electronics. The machine incorporates the core SAP-1 hardware blocks: a program counter, a memory address register, an instruction register, a control unit distributing signals across yellow bus wires, an accumulator, a B register, an arithmetic logic unit limited to addition and subtraction, and an output display. Eater substituted 16 bytes of RAM for Malvino's programmable read-only memory. Eater also introduced custom hardware and software modifications over the textbook baseline. He replaced the original binary display with a decimal readout and expanded Malvino's five-instruction set (LDA, ADD, SUB, OUT, and HLT). The enhanced instruction set incorporates immediate load, a store accumulator instruction (STA) to write back to memory, unconditional jumps, and a conditional jump evaluated against an addition overflow carry bit. First-Principles Reconstruction Series (3:24) To address viewer requests for schematics, Eater plans to build a duplicate computer entirely on camera. His stated instructional approach is to derive and explain each component from first principles, ensuring viewers understand the physical and logical mechanisms rather than accepting predetermined circuits blindly. Eater projects the complete reconstruction will require at least several months due to limited free time, targeting a publication pace of at least one video per week. He asserts that viewers do not require prior electronics experience to reproduce the computer, contending that successful assembly requires primarily neat wiring habits and systematic error diagnosis. Variable Clock Module and Diagnostics (5:06) The build series begins with the master clock module, scheduled for release in roughly two weeks following travel. Built using 555 timer integrated circuits, the module serves as the central timing coordinator for the entire system. The circuit provides three distinct operational states: continuous execution with variable frequency adjusted via potentiometer, a full halt mode, and a manual single-step button. Eater highlights manual stepping as an essential diagnostic feature, allowing builders to cycle the computer one pulse at a time to isolate wiring and logic errors during assembly. While Eater aims to provide a complete guide for viewers to build and expand upon the SAP-1 architecture, the project's overall duration remains contingent on his weekly filming schedule and the pace of explaining each component from scratch.

Source quotes

[3:24] Ben Eater: I'm convinced that anyone can build this and really understand at a very deep level, how a computer works, by building this

Original transcript

[0:00] Ever since I uploaded a few videos of this 8-bit programmable computer, [0:04] that I built a while ago, I've gotten a lot of questions about it. [0:07] I wanted to answer a few of the most common questions, [0:10] and definitely by far the most common question, [0:12] is, "can you show us how to build it?" or "do you have schematics for this?" [0:16] Or something along those lines. The answer is, believe it or not, I actually don't have schematics [0:21] for this thing, I never sat down and drew out a full schematic. [0:27] Because of how modular everything is, or how modular this architecture is, [0:31] I was able to build each piece of it by itself, and build it, and test it, and experiment with [0:38] one module at a time, before I had to put it all together. It wasn't really until all the pieces came together [0:45] that I really had to be a little bit more thoughtful about how it was all going to work. [0:50] For that I had this really good model to follow in this book that I really recommend, [0:55] "Digital Computer Electronics", by Albert Paul Malvino. [0:58] Unfortunately, I think the book is out of print, but hopefully you can find a used copy online [1:04] or something. This book has an architecture... has a couple architectures. [1:09] One is the SAP-1, which is, "simple as possible". The goal is to be a very simple computer architecture, [1:18] that demonstrates all the crucial ideas behind computer operation [1:21] without being any more complicated than it needs to be. [1:26] The architecture that they have in here, is basically the model that I followed, [1:31] what I based this computer on. So you can see that all of the same components are there. [1:35] There's a program counter here, there's the memory address register, [1:39] the 16 bytes of memory that are used, programmable read only memory, [1:44] I've got RAM but, same difference, as far as the operation is concerned. [1:49] An instruction register, the control unit, which is all this stuff down here, [1:53] and you can see that they have all these signals going out, that come back in [1:57] to all the other components, and that's what all these yellow wires are. [1:59] They're all the control signals. They come from the control unit and go out [2:02] to all the different pieces to orchestrate everything. [2:05] The accumulator, which is the A register here. The ALU, which is the arithmetic [2:11] logic unit, which in this computer, just adds and subtracts. [2:14] Those are the only arithmetic operations it knows how to do. [2:17] And then the B register. The A and the B register are the inputs for the arithmetic. [2:23] And the output register, they have a binary display, I've got a decimal display [2:27] which I thought was a little nicer. [2:29] That's one enhancement that I made. [2:32] I made a few other enhancements to this as well, primarily around the instruction set [2:36] and what you can actually do with it. [2:38] The model here in the book, it talks about the instructions having a [2:42] "load A" instruction, an add instruction, subtract, output, and halt, and that's it. [2:48] I added a couple other things. I added a load immediate, which just lets you [2:52] save a little bit of memory, if you wanted to load a particular value into the A register. [2:57] And then a "store A" command, which in addition to the "load A," which loads the accumulator [3:03] from memory, you can store what's in the accumulator to memory. [3:06] So that let's you build a little bit more complex programs. [3:10] I also added jump instructions, which I thought were pretty important [3:13] for a programmable computer. There's a regular jump instruction, [3:16] there's also a conditional jump instruction, that jumps when the carry bit is set, [3:20] anytime the addition over flows. [3:24] So you might still be wondering, can I just tell you how to build this thing already, [3:30] can you draw up a schematic or something like that? Well, I've got some good news. [3:34] That is exactly what I plan to do, to make a bunch of videos, that go through every step of the process. [3:40] I am planning to actually build a whole new copy of this computer from scratch, [3:46] and have videos of all of it. The bad news is that it's going to take a while. [3:52] I don't have a ton of free time, unfortunately, but my personal goal is to make one video a week, [4:02] at a minimum. So we'll see how well that goes, but even with that, I want to make sure I'm covering [4:08] everything from first principles, not leaving any mystery about why things work the way that they do. [4:14] I don't wanna ask you to take anything on faith, but going step by step, [4:20] probably means it's going to take a while to get to everything. So at least... [4:25] at least a few months. Probably longer. I hope that it will be worth the wait. My goal, and I'm convinced that [4:34] anyone can build this computer. As long as you're patient enough to wire it all up, carefully, [4:42] and you have the persistence to troubleshoot the inevitable wrong connections, [4:47] or broken connections or something. I'm convinced that anyone can build this and really understand [4:54] at a very deep level, how a computer works, by building this. Even if you, don't have any experience with [5:00] this sort of thing, or with electronics. In fact I really hope, I'm really looking forward to that happening, and [5:06] people building these things, and improving on it even. So, I think for the next videos, I'm going to be [5:15] traveling over the next week, so it may be in a couple weeks before I can get the next video up. [5:20] My goal is to just start focusing on the clock, as the first steps, and walk through [5:29] building this, the clock circuit, from scratch. There's a couple interesting things going on here. [5:34] The clock, of course, coordinates everything in the computer, the timing of everything. [5:40] In this case, you can adjust the speed of the clock, you can see here I'm slowing it down, [5:45] so everything else is running slower. You can also stop the clock, and then step one step at a time, [5:54] which is very useful for troubleshooting something, if something isn't working, which inevitably, [5:59] if you build this you're going to run into a point where something isn't working, and you need to [6:03] go step by step. A couple features that are of the clock, is that it uses the 5-5-5 timers, [6:08] so I will go through how those work, and they're being used in a couple different applications, [6:13] in the clock circuit. So, I think that that's the next thing that I'll do, the next set of videos. [6:17] You can look forward to seeing those. I hope you're as excited as I am about this. [6:23] Again, I ask for your patience, it's going to take a while to get through it all, [6:26] but I hope it will be worth it. If this is exciting to you, please give this video a thumbs up, [6:33] and subscribe to the channel, tell all your friends, cause if you like what you see, [6:38] knowing that people find these videos valuable, is really motivating to me, so [6:43] subscribing and watching the videos, is honestly the best way to make sure that I [6:48] keep working on them. Thanks for watching.