How Microprocessors are Built and Programmed

In this lecture we explore how transistor manufacturing went from bipolar junction transistors, to planar transistors and eventually photo-lithography and wafer scale manufacturing.  All of these innovations meant that transistors became smaller, denser and less expensive to make.  Coupling that with the improvements in power consumption and heat, led to the almost exponential increase in computing power from the 1950's to the present.

In this lecture we explore the Mistic VLSI layout tool and construct a NOT and NAND gate using the tool.  Mistic can lay out Metal, Polysilicon, N-Doped silicon and P-Doped silicon and includes a simple circuit emulator.  Mistic works in the browser and is inspired by the open source Magic VLSI layout tool and circuit emulator developed at Berkeley in the 1980's.

For more information and assessment and the VLSI layout editor used in this demonstration, see www.ca4e.com.

In this walk through, we explore the VLSI layout design tool used in Computer Architecture for Everybody, where circuits are built by painting layers that model real photolithography-based chip fabrication.

Using a CMOS NOT gate as an example, this video shows how:

P-diffusion, N-diffusion, polysilicon, and metal layers interact

Transistors are formed at diffusion–polysilicon intersections

Vias connect layers in a true 3-D layout

Voltage and ground propagate through metal and diffusion

CMOS behavior emerges naturally from the physical layout

We build the NOT gate from scratch, test its behavior by toggling inputs, and submit it to the autograder to verify correctness.

In this walkthrough, we build a CMOS NAND gate step by step using the VLSI layout design tool from Computer Architecture for Everybody.

Starting from the reference diagram, we lay out:

• PMOS transistors in parallel connected to VDD

• NMOS transistors in series conected to ground

• Polysilicon gates that form the transistors

• Metal routing and vias to connect layers correctly

In this lecture we focus on representing numbers with 0's and 1's using base-2.  Then we look at who we can add base-2 numbers with gates (and transistors) using half-adder and full adder circuits.   We ultimately explore a reusable three-bit adder component.  Nixie tubes make a reappearance in the "Nixie Challenge" - a game to learn base-2 conversions.  There is also a game called "Truth" that helps students learn the truth tables of the various logic gates.

In this lecture we look at how we can create feedback loops taking the outputs of gates and feeding them into inputs of gates.   We look at SR latches, Gated D latches and eventually construct a three-bit register component.

In this walkthrough for Computer Architecture for Everybody, we explore the Gates Layout and Simulation Tool and demonstrate how to build, connect, and experiment with digital logic circuits.

The video covers a wide range of features, including placing inputs and outputs, logic gates, adders, latches, and visual components like Nixie displays. We look at how to wire circuits, rename and tag signals, use automatic layout and waypoints to improve readability, and understand how higher-level components ultimately map down to transistors.

You’ll also see how to save and load circuits using browser local storage, edit existing designs, and experiment safely without losing your work. The walkthrough briefly touches on accessibility features, command-based component placement, and circuit simulation behavior.

This video is designed to give you a practical introduction to the Gates Layout Tool and help you feel comfortable experimenting with logic circuits as you move deeper into computer architecture concepts.

In this walkthrough, we complete a simple autograded logic assignment by building a two-input AND gate with one output.

The video shows how to place components using both the palette and the command interface, connect inputs and outputs, and test the circuit interactively. We then walk through the autograder process, including common mistakes such as missing or incorrect signal labels, and how to fix them using the tag tool.

In this walkthrough, we build a half adder using the Gates Layout Tool.

The video walks step by step through the build, starting from the reference diagram and implementing the circuit using an exclusive OR (XOR) gate for the sum and an AND gate for the carry out. We connect inputs A and B to both gates, label all required signals, and verify the circuit by manually testing the truth table.

You’ll see how the sum and carry outputs behave for all input combinations, how to fix common labeling mistakes.

This walkthrough is designed to reinforce how half adders work at a logical level.

I hope you find this half adder walkthrough helpful—happy building!

In this lecture we look at how delay and speed is measured in circuits.  Once the delay in a particular CPU is determined, it is used to choose a clock rate for the circuit.  We take a quick look at Moore's Law where for a relatively long period transistor density doubled approximately every two years.

In this lecture we build a CPU that executes one instruction per second.  The CPU is a single three-bit register and supports two instructions.  One instruction increments the current value in the register and the other instruction resets the register to zero.

In this lecture we look at how a CPU might retrieve is instructions from memory versus reading a switch.

In this walkthrough, we explore how to build a clocked counter using a three-bit adder, a latch (register), and a clock signal in the Gates Layout Tool.

Starting from basic components, we connect an adder and a three-bit latch to create a circuit that counts from 0 to 7. Along the way, we examine how latches store state, how clock signals control when values are copied, and why clocked circuits are essential to making counters—and CPUs—work reliably.

In this walkthrough, we build a minimal two-instruction CPU starting from a simple counter circuit.

We begin by reviewing how an adder and register form an incrementing counter, then extend the design with instruction decoding logic that allows the circuit to behave differently based on an external instruction input.

In this lecture, we dive deep into how computers really work — by exploring microprocessors through machine language, assembly language, and CPU architecture. We begin with a simple two-instruction CPU from the previous section and gradually build toward a simulated 6502-style CPU — the CDC 6504, inspired by the classic CDC 6500 and the legendary MOS 6502.

In this lecture, we explore base 16 (hexadecimal) — the number system widely used in machine language, character encoding, memory addresses, and CPU design. While binary (base 2) is foundational, it's too cumbersome to use directly for larger values like 8-bit characters, so hexadecimal becomes a practical and compact alternative.  We cover hexadecimal in anticipation of learning the architecture and instruction set of the CDC6504.

In this lecture, we connect high-level programming (Python & C) to the machine language that ultimately controls real computer hardware. Every line of code — no matter how elegant — must eventually be converted into zeros and ones that the CPU executes via wires and memory.

To truly understand programming, we must understand the machine that runs it - in this case we will learning to write machine code and assembly language using the CDC6504 - an emulator based on the MOS6502 microprocessor.

In this lecture, we explore the CDC 6504 architecture—an emulator based on the historic MOS Technology 6502 and named in homage to the CDC 6500, the first computer I ever used. You’ll hear the story behind the 6502’s impact, why the emulator needed a unique name, and see artifacts from my own 1979–1980 compiler work on the CDC 6500. We then examine the key CPU registers, walk through a simple machine language program that computes 1 + 1 = 2, and connect it back to earlier latch-and-adder designs. By the end, you’ll understand how the foundations of transistor-level logic grow into a full working CPU—without needing a billion-dollar fabrication facility.

In this lecture, we take a focused dive into the machine language of the CDC 6504 emulator. Building on previous lectures, we review the key CPU registers, explain immediate 16-bit instructions, and explore how index registers enable loops and array access. From comparisons and flag setting (Z and N) to conditional jumps, we see how branching replaces high-level constructs like if, for, and while. We then transition to assembly language, showing how labels and two-pass assembly remove the pain of calculating jump addresses by hand. By the end, you'll understand how simple instructions—load, compare, jump, and increment—combine to form full control structures in assembly.

In this tutorial, we dive into building more advanced machine language programs on the CDC 6504 emulator. We start with a quick review of the architecture, including the program counter, accumulator, X and Y registers, and flags, before exploring how to use DATA directives to preload memory with strings and constants. You’ll see simple programs in action, from adding numbers to printing “HELLO,” and then progress to a more complex example that converts a string to uppercase. Along the way, we compare how this same task would look in C and Python, and break down the assembly language step by step, including loops, indexed memory access, and conditional branching. By the end, you’ll have a clear understanding of how to work with the CDC 6504 emulator and write practical machine language programs.

In this video we switch to a new topic: CPU emulation — using the CDC6504 machine language emulator to explore how a simple CPU executes instructions step-by-step.

We’ll walk through the emulator interface, look at registers and memory, and see how a program moves through the instruction stream while changing CPU state (PC, flags, accumulator, and index registers).

If you’ve been following the earlier logic-gates / counter material, this is the moment where the pieces start to feel like a real computer.

This time the focus is on execution: stepping through instructions one at a time and watching how CPU state changes as the program runs. By slowing the machine down, we can clearly see how registers, memory, and the program counter interact during real instruction execution.

This approach helps bridge the gap between earlier topics like logic gates and counters and the behavior of an actual stored-program computer.

Using the CDC6504 machine language emulator, we build and trace looping behavior step-by-step by watching how branch instructions change the program counter and cause the CPU to repeat a sequence of instructions. You’ll see exactly what makes a loop a loop — not magic, just control flow.

Using the CDC6504 machine language emulator, we explore how a CPU makes decisions by testing conditions and selectively changing the program counter. By stepping through instructions one at a time, you can see exactly how comparisons, flags, and conditional branches work together to control execution flow.

This makes high-level concepts like if, else, and decision-making feel concrete and mechanical rather than mysterious.

In this video we put everything together by writing a small but meaningful machine-language program: converting a string to uppercase.

Using the CDC6504 emulator, we step through code that reads characters from memory, tests their values, conditionally modifies them, and writes the results back. Along the way, you’ll see how loops, conditional execution, and memory access combine to perform real string processing — one instruction at a time.

This example ties together several core CPU concepts and shows how familiar high-level ideas emerge from simple low-level operations.

You just built code in a 6502 CPU emulator — but that’s only the beginning. In this video, I show how a simple JavaScript emulator running in a browser connects directly to modern computing, WebAssembly (WASM), and even full Atari 2600 emulation running faster than the original hardware.

In this video, we explore the major evolution of CPU architectures — from the rise of RISC vs CISC, to the great consolidation into only two dominant CPU families today: ARM and Intel. We walk through Apple’s fascinating processor history — switching from 6502 → Motorola 68000 → PowerPC → Intel x86 → ARM (Apple Silicon) — and how Rosetta 1 & 2 made the impossible transitions between CPU architectures possible.

In this lecture, we use a small JavaScript example to introduce WebAssembly (WASM) and talk about how code moves from source text to something that can actually run on a machine.

We look at the role of programming languages, functions, and execution, and how WASM fits between high-level code and low-level machine instructions. This sets the stage for later lectures where we explore what WASM looks like inside and how it maps to computer architecture concepts.

This video is part of a larger sequence connecting software to the hardware it runs on, one step at a time.

In this walkthrough, we look at how C programs can be compiled to WebAssembly (WASM) and executed directly in the browser, just like the examples used on the free in-browser WASM emulator used in this course.

We step through the compilation process, talk about what the browser actually loads and runs, and connect traditional compiled languages like C to the WebAssembly execution model. This helps bridge the gap between classic systems programming and modern web-based execution environments.

This video is part of a larger sequence exploring how high-level code becomes low-level instructions, and how WebAssembly fits into computer architecture concepts.

In this walkthrough, we build a simple function that converts a string to upper case and use it to explore how loops, break, and continue work at runtime.

As the code runs, we look at how function calls use the stack and stack frames, and how control flow moves through the loop. This provides a concrete way to connect everyday programming constructs to what’s happening during execution in WebAssembly (WASM).

This video is part of a larger sequence connecting high-level code to low-level execution concepts, including memory, control flow, and the call stack.