3/15/2026 11 AM - Game Ideation + Logic Gates

This project is starting a bit differently from the others, as originally it was my late start to the Christmas competition (hence the name).

I had really wanted to make a DTL computer, meaning Diode Transistor Logic. I found I would be able to structure these components into a way where I could create logic gates, and therefore my whole computer.

This type of computer is generally what was found in early mainframe computers, as transistors were expensive and diodes were cheap and faster compared to relays. Eventually this style of computing was fazed out and replaced with more transistor logic as chips got cheaper and cheaper to manufacture.

These mainframe computers with multiple computational cards fascinated me, and I wanted to try and make one. By making multiple cards I would be able to make the computer both smaller and cheaper, but more complex.

Instead of making a full turing computer, I would make the game itself completely out of direct DTL logic.

Now I wanted to make a game, but it needed to be somewhat simple. My idea was a variation of a program called "Kill the Bit" created sometime in 1975. I would use the similar kind of conveyer logic but change it to Gifts and Coal from the santa factory. I also added some "chutes" where the player would pass either a Gift or Coal to add to their score (or detract from their health if they got it wrong).

This is what I first imagined the game would be like:

Each of the circles would be a place on the conveyor for either a Gift or Coal, and each of the lines would be a chute controlled by the player.

I then later explained the game to my friend and fleshed out this:

Any remaining Gifts or Coal at the end of the chute would lead to the loss of a heart, and the items would be generated on the right and move each clock cycle to the right. (Or down if in a chute)

Each chute is coded to either a Gift or Coal, and if the wrong item is dropped inside it would lead to the loss of a heart.

I also created some mini circuits for the logic gates I needed for the program.

With these 4 gates, I would be able to make almost all of the logic needed for the program.

I did also need something for storage, so I created a D-Flip Flop out of my existing gates. After this I also made a XOR gate and a SR Latch This is going to be a ridiculously complicated KiCAD document...

3/15/2026 12 PM - Conveyor and Chute Implementation

The game on its most basic level is storage, and changing how the bits in that storage move around creates the game.

On this note, I created the backbone of the game with the main conveyor and chutes.
This was done by stringing together a number of D-Flip Flops with special output gates on each of the conveyor sections that would serve to stop the output from continuing down the conveyor if it was supposed to branch down into the chute.

These outputs were controlled by a smaller input circuit tied into SR latches, allowing me to hold the user input until it is needed for computation and movement of bits.

I also created the chutes by using a version of the main conveyor but with tweaked inputs and outputs.

These circuits on their own are already mildly complex, but together this gets to something a bit insane:

The top section is the schematic for the main conveyor, and the bottom section is all of the chutes.

Working in such a large complicated KiCAD project is the main challenge here, making sure every single wire is correct. I was able to copy over the larger components, but making absolutely sure that each of the larger components is connected correctly is pretty difficult.

The schematic sheet size is over twice as big as the largest default selectable schematic size lol

3/15/2026 2 PM - Clock and "RNG"

All computers need a clock, and this one is no different. These will be the only IC chips on the board, as I wanted the ability to easily modify the game tick values, as well as not having to deal with a crystal oscillator conversion down to some reasonable game speed.

I will be using 555 Timer ICs on the board, and I needed to figure out the correct circuit I needed to get a good initial game tick. I found this calculator online which I used to tune in my clock values:

Now, since I wanted the ability for the inputs to be held until they were needed by using SR latches on the inputs, I also needed a more accurate clock start tick. This tick pulse would be used to reset the SR latches during each clock cycle. This was actually fairly difficult to get right, and is the first thing I have pulled out an electronics simulator to complete:

After getting this clock tick working in the simulation I remade the circuit in KiCAD:

This meant I had all of these supporting components:

The next challenge was creating the "random" item to go into the conveyor. This is pretty hard for bare iron components to do, so I created an LFSR or linear feedback shift register. This kind of register would allow me to create a sudo random number by including XOR gates throughout certain parts of the register. I chose to create a 5 bit LFSR since it would allow my game to have 31 states, plenty enough to feel completely random. (This is more than double what a 4 bit LFSR which would have only held 15 states.)

Heres what my LFSR looks like:

3/15/2026 4:09 PM - Backplane, Scoring, and Player Health

Since this computer has so insanely many individual components (over 1400!) the computer needs to be split up into multiple 'cards'. These cards can then be plugged into the backplane to connect them all to each other, allowing proper communication and data transfer. On this note, I was inspired by the Undercity nametags to use a PCI connector. To get the number of connections I would need for the board, I figured I might as well use a PCI x16 connector.

I had first tried routing this as a 2 layer board, but I quickly discovered that these pins are packed so tightly together that I needed to use a 4 layer board to properly connect everything:

This is the completed routing:

I added 7 PCI slots since thats what would fit inside a 100x100mm board. This should give me 1 extra expansion slot for the computer, as I expect to have 6 cards in the current design.

The next part of the computer I worked on was the health system, which would be a counter made of DFFs that continually gets added to whenever the user takes damage.
I then created this to figure out how to properly display the health on LEDs as a healthbar:

Here's what that looks like translated into logic gates:

The last thing I worked on here was the scoring system, which I made by stringing together 8 DFFs together to create an 8 bit register. This allows me to provide a single input in the front of the register and have it add 1 in binary each time.

Here we have the score and health combined together into their section:

I also cleaned up the schematic into nice rectangles as seen here:

I also realized it would be really really difficult to create the multiple PCBs from a single KiCAD project, so I created a new project and copied the libraries over for every single board. Since KiCAD makes it so hard to rename a project I ended up creating 6 new project then readding everything I needed for each part.

3/15/2026 4:30 PM - First Computer Card - State Manager

The simplest (and smallest) computer card would be the state manager, and would contain most of the supporting components (Clock + Random number generator) as well as the power supply for the computer.

This is what the entire schematic for this board looks like:

The 5 bit LFSR is the main component here that makes the schematic look so big.

Despite being the simplest board, figuring out how to fit all of the individual components on the board was one of the things that took the longest. Now that I have some kind of idea on how to put together the D-Flip Flops it should save me time later (as I will need to make over 40 of them over the course of the project...)

The routing could have been cleaned up a little bit but at this point I was really really tired (as it was pretty late).

Heres what this board looks like in 3d!

It almost looks like a graphics card from its more horizontal appearance. The next boards will be created as a square to maximize effective area for the price. (I was planning on 200x200mm)

3/15/2026 4:55 PM - Second Computer Card - Scoring and Health

The next most simple PCB card would be the Scoring and Health card. This card is pretty self explanitory, but it would deal with holding the score and health of the player, as well as controlling how it changes based on the current game state.

This is what the schematic looks like:

The block on the right is the PCI x16 connector (The new part for this section)

Once again, laying out the hundreds of components was by far the hardest part of this process, and just this part alone took over 3 hours:

Now the next challenge. Since I was getting so many PCBs and I wanted to keep costs down as much as I could, I needed to attempt to use a 2 layer copper board.

While it was the second easiest board in the project, it was just on the edge of needing another layer, but everything did fit just fine:

You can see in the screenshot some of the buses running across the board ^^.
This one looks pretty cool too:

Just a reminder that every single component was placed individually on the board, there was no copy pasting available (since it would then not match with the schematic).

If you do have a better way to do a massive board like this, please let me know.

3/15/2026 5 PM - Third and Fourth Computer Cards - Chutes

The major time sink in the previous boards has been mainly from the tedious placement of the individual components in the D-Flip Flops. Over these two boards, I would need to make 30 DFFs, which would have been equal to more than double the PCB work I had done up to this point.

Clearly I had to find another option, so I turned to shenanigans.
I created my own "footprint" that was a combination of all objects in the DFFs and added the routing by drawing out the traces.

These were looking a bit thin though, so I beefed up the traces:

I also added the 3d models into this footprint by having it reference each part a bunch of times lol.

By doing this change I was able to simplify the schematic from this:

into this:

Now that all of these were together, it would allow me to place an entire set of DFF components at a time. (Highlighted in green here):

Now there was still a crazy amount of stuff to do for this board:

This was the point when I knew I would absolutely need 2 boards for all of the chutes. On the right is what I could fit on the board, and on the left is the other half that doesn't fit:

After placing the half of components and routing this board, it looks like this:

and even has no errors!

Well, almost anyway. There was no way I was going to get the display output I needed from the board in its 2 layer configuration, so I will need to add some wirewrap to the boards in something that would look like this:

So finally this first board looks like this:

The second board follows essentially the same process, just connecting up the remaining chutes that didnt fit on the other board.
There were some difficulties while routing (probably because it was a little late) but I got everything to work:

2 full boards done in a day!

3/15/2026 6 PM - Fifth and Final Computer Card - Main Conveyor

Alright with the new footprint I made in the previous session, this should be a lot less painful. This board will be the most complicated one, but everything here should fit. (Especially with my new usage of the 3rd and 4th layers to use as manual wire wrap.)

The first thing I did was fix the main conveyor schematic so that it used my new footprint:

I then imported all the parts into the PCB studio and started laying them out on the board:

These boards really do look awesome with so many individual components.

After I finished putting all the components down on the board, I started routing the entire PCB. This was made slightly easier by my usage of the 3rd and 4th layers, but since there was still a ton of stuff on this board it still took quite a while.

After a couple hours I had this:

This means the entire computer is complete! (and just needs a display for the information)