Skip to the content
4 layers194.5 × 188.6 mmMyCpu, the printed circuit board in 3D

Home brew CPU Hardware with 1-bit ALU implementation using 74LSxx, a micro-code and assembler coded in C#.

Size
194.5 × 188.6 mm
Copper layers
4
Thickness
1.6 mm
Parts
162
Nets
239
Pads
1,078
Tracks, vias
2,736, 666
Pours
2
Routed
Yes
KiCad
KiCad 9.0 (file 20241229)
Created
5 Dec 2023
Updated
7 Nov 2026

Overview

MyCpu is an open-source printed circuit board by fortinsylvain, from the fortinsylvain/MyCpu repository on GitHub, published under the MIT licence. It is a 4-layer board of 194.5 × 188.6 mm with 162 parts on 239 nets, routed with 2,736 tracks and 666 vias.

It is built around the 74LS245SC, 74LS374PC and 74LS00SC, with the 74LS153DC, 74LS04PC and 74LS151PC among its other parts. Its parts include 47 resistors, 39 capacitors, 35 ICs, 19 diodes and 13 connectors. It belongs with the sensors and measurement and retro computing and games boards and the FPGA and CPLD boards of this library.

Main components

12

README

README.md

Homebrew CPU Project

I built this CPU at home using 74LS logic ICs, EEPROMs, RAMs and GALs, driven by curiosity and a desire to understand processor design at a fundamental level.


🔧 Project Overview

My goal was to create a fully functional CPU using a 1-bit ALU. While this results in relatively slow execution speeds, it allows me to explore the control and datapath mechanisms in detail.

  • All microcode for the CPU is stored in two binary files programmed into 2864 EEPROM chips.
  • A custom microassembler generates these micro-instructions.

🧠 Custom CPU PCB Update

After validating the core architecture on a wire-wrap prototype, the custom PCB version of the CPU is now complete. The boards were professionally fabricated by PCBWay, thanks to a generous sponsorship offered by Liam from their marketing team, who discovered the project on GitHub. This support helped transition the design from a hand-built prototype to a professionally produced PCB.

KiCad PCB Design

🛠️ PCBWay Manufacturing Review

I’m happy to share my experience working with PCBWay for manufacturing the custom PCB version of my CPU project. Here's a quick summary of how it went:

First, I transferred the handwritten schematic into KiCad, then completed the routing for each required part. I was able to find all the necessary components on AliExpress. After carefully checking my Gerber files, it was time to send the design to the factory.

🔁 I was genuinely impressed by PCBWay’s one-click KiCad integration — all design files were submitted automatically to the PCBWay factory with a single click. No file packaging, no ZIP uploads — just click and go! The ordering process was fast and seamless.

🌐 The web interface was intuitive and transparent, allowing me to track each step of the production process in real time.

📦 The PCBs arrived astonishingly quickly, properly boxed and well-protected with excellent packaging. Although I ordered 5 boards, PCBWay generously included 6 — a thoughtful bonus!

The soldering process went smoothly. I used footprints optimized for hand soldering, with larger pads to make it easier to work with. Only a couple of 0603 surface-mount resistors are present on the board.

🔌 First power-on: the board worked on the first try! I reused the same microcode and program EEPROM, along with the GAL, that were previously tested on the wire-wrap prototype — total success.

Since the new board has a solid ground plane, I expect it will run faster than the prototype, with improved signal integrity. I plan to validate this with an oscilloscope soon — stay tuned for updates!

🌍 There’s a strong online community around PCBWay, full of shared open-source hardware projects — very inspiring!

🧠 Board design files

Download Schematic PDF

🧵 Wire-Wrap Prototype

Before moving to a PCB, I built a wire-wrap prototype to test the design on real hardware. This stage was essential for debugging the microcode, verifying timing, and refining the instruction set.

Wire-Wrap CPU

Here’s a picture of the back — a lot of patience was required! Amazingly, it's still holding together and executing code after 30 years.

Wire-Wrap CPU

Wire-wrapping made it easier to make changes during development while still providing a reliable and compact way to interconnect components.


Microcode and Assembler

💾 Download Microcode Source
💾 Download Microcode Assembler
💾 Download Opcode Assembler
💾 Download Diagnostic Program


GAL source files

In the PCB version of MyCPU i make use of programmable logic devices (GALs) for clock phase generation, address decoding, and microcode ROM decoding tables. The source files were compiled using WinCupl, and the chips were programmed using a TL866II Plus programmer.

💾 Download GAL22V10 Clock 💾 Download GAL22V10 Decoder 💾 Download GAL16V8 ROM0 💾 Download GAL16V8 ROM1

🧠 Register Implementation on RAM

The design uses address-mapped RAM to support the CPU’s operation. This approach saves chip count, though at the cost of execution speed.

The following registers are implemented in RAM:

  • Instruction Pointer
  • Register A
  • Carry Flag
  • Equal Flag
  • Index Register
  • Stack Pointer
  • The Stack

Here is the memory address map:

0000H - 17FFH Total RAM space

  • 0000H - 17FFH Total RAM space
  • 0000H - 00FFH Stack
  • 0100H - 17EF Free for application
  • 1FF0H SP Stack Pointer 8 bit
  • 1FF1H JSH Temporary storage for JSR MSB address
  • 1FF2H JSL " " " " LSB "
  • 1FF3H XH Index Register MSB
  • 1FF4H XL Index Register LSB
  • 1FFAH E bit<0> Equal Status bit
  • 1FFBH C bit<0> Carry Status bit
  • 1FFCH A Register
  • 1FFEH IPH Instruction Pointer MSB
  • 1FFFH IPL Instruction Pointer MSB
  • C000H LED port
  • E000H - F000H EEPROM for application program

System Overview

Top-Level Architecture Diagram

Top-Level Diagram

Hand-Written CPU Schematic

When I started this project back in 1995, I didn’t have access to schematic capture software or a decent computer that could run it. I only had an IBM Personal Computer XT, so I used pen and paper to sketch how the electronic components were connected.

CPU Schematic

CPU Board Layout View

CPU Board Layout


Microcode and Control ROMs

The microcode is stored in two 2864 EEPROM ICs. Originally, a BASIC program was used to translate a text file of micro-instructions into a .hex file. A homemade EEPROM programmer was built to write these files via the parallel port of an IBM PC XT.

Today, a modern C# program performs the same translation into .hex format for programming.

The ROM decoding table encodes how data moves between components. This reduces the number of control bits required by expanding microcode control using external PROMs.

  • ROM chips: IC20 and IC21 (74S188, 256×1 Open Collector PROMs)
  • These are one-time programmable PROMs.
  • Several chips were sacrificed before the correct decoding table was finalized.

Decoder ROM Table

In the PCB version of the board, two GAL16V8 replaces the PROMs to implement the decoding table, offering greater flexibility and eliminating the need for one-time programmable chips.


I/O Board Schematic

Wire wrap proto required a second board to include the following:

  • RAM
  • EEPROM (for application program)
  • LEDs for visual feedback

The PCB version includes all of these components on a single board.

I/O Schematic


Debugging Setup

Initially, I was single-stepping using push switches, LEDs, and a pair of classic TIL311 hex displays to monitor the 8-bit data bus on the wire-wrap prototype, but it quickly stopped being fun. When bugs like stack corruption became too tricky to debug, I decided to get an Agilent 1670G Logic Analyzer. I found one on eBay for 510 CAD, which seemed like a reasonable price—I never thought I’d own one! It’s the color LCD version, so now I get to see the word in color.

With the analyzer, I can trigger on specific conditions and even do some reverse assembly of the microcode using basic symbolic decoding. It allow recording of detailed intructions traces. Quite cool!

Final Wire-Wrap Assembly with Logic Analyzer

Here the Logic analyzer connected to MyCpu for a debug session. Wire-Wrap and Logic Analyzer

Microcode View on Logic Analyzer

Microcode Disassembly


MyCPU Instruction Set

This document describes the instruction set of the MyCPU homebrew processor.


📘 Overview

  • 8-bit accumulator architecture (A, X registers)
  • 16-bit addressing support
  • Flags: E (equal/zero), C (carry)
  • Stack support (SP-based)

📑 Instruction Set


Data Movement

MnemonicOpCodeBytesModeFlagsDescription
LDA #0x**0x301Hex-Load immediate into A
LDA 0x****0x2A2Hex-Load A from memory (absolute)
LDA @0x2A2Symbol-Load A from memory (symbolic)
LDA (X)0x0A0Hex-Load A from memory indexed by X
STA 0x****0x312Hex-Store A into memory (absolute)
STA @0x312Symbol-Store A into memory (symbolic)
LDX 0x****0x342Hex-Load X from memory
LDX @0x342Symbol-Load X from symbolic address
STX 0x****0x162Hex-Store X into memory
STX @0x162Symbol-Store X into memory

Arithmetic / Logic

MnemonicOpCodeBytesModeFlagsDescription
ADDA #0x**0x2F1HexCAdd immediate to A
ADDA 0x****0x292HexCAdd memory to A
ADDA @0x292SymbolCAdd memory to A (symbolic)
ADCA #0x**0x2E1HexCAdd immediate + carry
ADCA 0x****0x282HexCAdd memory + carry
ANDA #0x**0x331Hex-Logical AND with A
ORA #0x**0x171Hex-Logical OR with A
XORA #0x**0x181Hex-Logical XOR with A
NOTA0x190Hex-Bitwise NOT A
INCA0x030HexEIncrement A
DECA0x200HexEDecrement A
CMPA #0x**0x2D1HexE,CCompare A with immediate

Control Flow

MnemonicOpCodeBytesModeFlagsDescription
JMP 0x****0x322Hex-Unconditional jump
JMP @0x322Symbol-Unconditional jump (symbolic)
JEQ 0x****0x2C2Hex-Jump if equal
JEQ @0x2C2Symbol-Jump if equal (symbolic)
JNE 0x****0x2B2Hex-Jump if not equal
JNE @0x2B2Symbol-Jump if not equal
JRA 0x**0x0C1Hex-Relative jump
JRA @0x0C1Relative-Relative jump (symbol)
JRNC @0x0F1Relative-Jump if no carry
JRUGE @0x231Relative-Jump if unsigned ≥

Stack & Subroutines

MnemonicOpCodeBytesModeFlagsDescription
JSR 0x****0x062Hex-Jump to subroutine
JSR @0x062Symbol-Jump to subroutine
RTS0x070Hex-Return from subroutine
PSHA0x240Hex-Push A to stack
POPA0x250Hex-Pop stack into A

Shift / Bit Operations

MnemonicOpCodeBytesModeFlagsDescription
SLLA0x0E0HexCShift left logical
SRLA0x0D0HexCShift right logical
RRCA0x100HexCRotate right through carry
RRC @0x142SymbolCRotate memory right
SRL @0x152SymbolCShift memory right

System / Misc

MnemonicOpCodeBytesModeFlagsDescription
NOP0x090Hex-No operation
STOP0x080Hex-Halt execution
SCF0x120HexCSet carry flag
RCF0x110HexCReset carry flag
CLRA0x260HexEClear A
CLRX0x1E0HexEClear X

Memory / Data

MnemonicOpCodeBytesModeFlagsDescription
DB 0x**0x000Hex-Define byte
.ASCII "@"0x000Ascii-Store ASCII string
EQU 0x****0x000Hex-Define constant

🧠 Notes

  • E = equality / zero flag
  • C = carry flag
  • @ = symbolic addressing
  • 0x**** = 16-bit address
  • #0x** = immediate value

🚀 Generated by MyCPU Assembler


Inspiration and Community

I began documenting this project after discovering other wonderful homebrew machines featured on:

👉 Homebuilt CPUs WebRing

Join the Ring!

Interested in joining the Homebuilt CPUs WebRing?

  • Contact Warren (email address is obfuscated—replace [at] with @)
  • Mention your page URL and request to join
  • Add the WebRing code fragment to your site

📌 Note: The ring is for actual home-built CPUs. Emulations of commercial parts are OK.
However, projects must be partially or fully built—paper designs don’t qualify.
Technologies used can include relays, TTL, CMOS, FPGAs, etc.

License

This project is licensed under the MIT License – see the LICENSE file for details.

Parts

162
QtyValueFootprintReferences
360.1uFCapacitor_THT:C_Disc_D6.0mm_W2.5mm_P5.00mmC1, C2, C10, C11, C12, C13, C14, C15, C16, C17, C18, C19, C20, C21, C22, C23 +20
19LEDLED_THT:LED_D5.0mmD1, D2, D3, D4, D5, D6, D10, D11, D12, D13, D14, D15, D16, D17, D18, D19 +3
18470Resistor_THT:R_Axial_DIN0207_L6.3mm_D2.5mm_P2.54mm_VerticalR4, R5, R6, R7, R10, R11, R12, R13, R14, R15, R16, R17, R18, R29, R38, R39 +2
100 OhmsResistor_SMD:R_0603_1608Metric_Pad0.98x0.95mm_HandSolderR22, R23, R24, R25, R26, R27, R28, R45, R46, R47
9330Resistor_THT:R_Axial_DIN0207_L6.3mm_D2.5mm_P2.54mm_VerticalR30, R31, R32, R33, R34, R35, R36, R37, R44
574LS374Package_DIP:DIP-20_W7.62mm_Socket_LongPadsU9, U10, U12, U13, U31
44.7KResistor_THT:R_Axial_DIN0207_L6.3mm_D2.5mm_P2.54mm_VerticalR19, R20, R21, R43
474HCT161NPackage_DIP:DIP-16_W7.62mm_Socket_LongPadsU14, U15, U16, U17
4Conn_01x09Connector_PinHeader_2.54mm:PinHeader_1x09_P2.54mm_VerticalJ8, J9, J10, J11
4MountingHole_PadMyCPU_Footprint_Library:MountingHole_3.2mm_M3_Pad_Via_Drill_0.5mmH1, H2, H3, H4
328C256Package_DIP:DIP-28_W15.24mm_Socket_LongPadsU18, U19, U70
374LS00Package_DIP:DIP-14_W7.62mm_Socket_LongPadsU23, U26, U28
210 uFCapacitor_THT:CP_Radial_D5.0mm_P2.50mmC36, C38
24.7kResistor_THT:R_Axial_DIN0207_L6.3mm_D2.5mm_P2.54mm_VerticalR2, R3
274LS153Package_DIP:DIP-16_W7.62mm_Socket_LongPadsU7, U8
274LS244Package_DIP:DIP-20_W7.62mm_Socket_LongPadsU6, U22
2Conn_01x08Connector_PinHeader_2.54mm:PinHeader_1x08_P2.54mm_VerticalJ3, J4
2Conn_02x17_Odd_EvenConnector_PinHeader_2.54mm:PinHeader_2x17_P2.54mm_VerticalJ1, J2
2GAL16V8Package_DIP:DIP-20_W7.62mm_Socket_LongPadsU20, U21
2GAL22V10Package_DIP:DIP-24_W7.62mm_Socket_LongPadsU29, U30
2IMS1423S35Package_DIP:DIP-20_W7.62mm_Socket_LongPadsU1, U2
11 kOhmsResistor_THT:R_Axial_DIN0207_L6.3mm_D2.5mm_P2.54mm_VerticalR42
110nFMyCPU_Footprint_Library:C_Disc_D6.5mm_W2.1mm_P6.50mmC35
11M OhmsResistor_THT:R_Axial_DIN0207_L6.3mm_D2.5mm_P2.54mm_VerticalR40
147 kOhmsResistor_THT:R_Axial_DIN0207_L6.3mm_D2.5mm_P2.54mm_VerticalR41
150 OhmsResistor_THT:R_Axial_DIN0207_L6.3mm_D2.5mm_P2.54mm_VerticalR1
174LS04Package_DIP:DIP-14_W7.62mm_Socket_LongPadsU33
174LS08Package_DIP:DIP-14_W7.62mm_Socket_LongPadsU27
174LS151Package_DIP:DIP-16_W7.62mm_Socket_LongPadsU3
174LS245Package_DIP:DIP-20_W7.62mm_Socket_LongPadsU11
174LS259Package_DIP:DIP-16_W7.62mm_Socket_LongPadsU5
174LS32Package_DIP:DIP-14_W7.62mm_Socket_LongPadsU24
174LS74Package_DIP:DIP-14_W7.62mm_Socket_LongPadsU4
174LS86Package_DIP:DIP-14_W7.62mm_Socket_LongPadsU25
1Conn_01x02Connector_PinHeader_2.54mm:PinHeader_1x02_P2.54mm_VerticalJ13
1Conn_01x06Connector_PinHeader_2.54mm:PinHeader_1x06_P2.54mm_VerticalJ12
1Conn_02x03_Odd_EvenConnector_PinHeader_2.54mm:PinHeader_2x03_P2.54mm_VerticalJ7
1EC1125HSTS 26.8 MHzOscillator:Oscillator_DIP-8Y1
1HDSP-4830_2Display:HDSP-4830BAR1
1HM62256BLPPackage_DIP:DIP-28_W15.24mm_Socket_LongPadsU71
1Jumper_3_Bridged12Connector_PinHeader_2.54mm:PinHeader_1x03_P2.54mm_VerticalJP1
1NE555PPackage_DIP:DIP-8_W7.62mm_Socket_LongPadsU32
1SMA ConnectorMyCPU_Footprint_Library:GSG-SMA-73251-2120_drill_0.5mmJ6
1SW_PushButton_Switch_THT:SW_PUSH-12mmSW1
1Screw_Terminal_01x02TerminalBlock_CUI:TerminalBlock_CUI_TB007-508-02_1x02_P5.08mm_HorizontalJ5

The 161 most common of 162 parts.

Similar boards

  • 2 layers486 × 306.3 mmMonacoGP, the printed circuit board in 3D

    MonacoGP

    stonedDiscord/MonacoGP

    Sega MonacoGP TTL Boards

    257 parts1
  • 2 layers630 × 300 mmSecretBase, the printed circuit board in 3D

    SecretBase

    stonedDiscord/SecretBase

    SEGA Secret Base Arcade Game

    441 parts
  • 4 layers254 × 137.7 mmS100 ColorMagic-1.1-006, the printed circuit board in 3D

    S100 ColorMagic-1.1-006

    RichCini/LomasBoards

    Small repository of files/data related to Lomas Data Products S-100 boards.

    150 parts1
  • 2 layers379.1 × 273.4 mmNE Delta, the printed circuit board in 3D

    NE Delta

    frubem/NE_Delta_Schematics

    Forked from https://codeberg.org/hkzlab/NE_Delta_Schematics

    185 parts
  • 2 layers400.9 × 280.5 mmAleste520v4, the printed circuit board in 3D

    Aleste520v4

    lucedoriente/Aleste520ex

    Western version of 1993 Z80 russian computer

    345 parts4GPL-3.0
  • 2 layers364 × 203 mmCPU6S, the printed circuit board in 3D

    CPU6S

    Meisaka/CenMiniCom

    Centurion Minicomputer Schematics

    240 parts8
  • 4 layers337.6 × 105.7 mmISA CGA, the printed circuit board in 3D

    ISA CGA

    hkzlab/CGA_Redux

    The Color Graphics Adapter Redux board is a more or less faithful clone of the original IBM CGA, based on the original schematics

    170 parts56
  • 2 layers426 × 307 mmI7000, the printed circuit board in 3D

    I7000

    felipesanches/Itautec_I7000_KICAD

    Esquemáticos do computador Itautec I-7000 G desenhados a partir de inspeção do circuito das PCBs

    115 parts

Questions

How big is the MyCpu PCB?

It measures 194.5 × 188.6 mm and has 4 copper layers, 1.6 mm thick.

What parts does the MyCpu use?

162 parts, built around the 74LS245SC, 74LS374PC, 74LS00SC and 74LS153DC. The full list of its parts is on this page, with links to each part's symbol and footprint where PCBKit's library has them.

Where can I download the MyCpu KiCad files?

From the fortinsylvain/MyCpu repository on GitHub, at the commit this page was made from: the board is Kicad/MyCPU.kicad_pcb and its schematic Kicad/MuCpu_counter.kicad_sch. PCBKit opens the board in the browser, with nothing to install.

Can I use the MyCpu design in my own project?

Its repository publishes it under the MIT licence: you may reuse it on that licence's terms (keep the author's notice, and for a copyleft licence share your changes alike).