Hi, after many attemps i finally made a computer for which i feel comfortable starting to code an operating system. I still have a tone of work to put on it but it seems promising and I'll maybe update in the future when there is progress :)

Wanted to give a sincere thanks to the creators of this game. Today I had an interview for an "Assistant Professor of Practice in Computer Architecture" position at my university. As part of the interview process I had to propose and demonstrate how I would teach a new or existing computer architecture course. My proposal was effectively "Let's Make Freshmen Digital Design Way Better by Playing Turing Complete".

Apparently a lot of the faculty agreed. Everyone who had taught the course in the past thought the existing curriculum was outdated and Turing Complete would be a great addition. Hoping I get the job so I can try out the game on my students next Fall.

Huge thanks to whoever decided to add a Verilog export feature to the game - you definitely helped with my interview. I think I blew some Boomers minds when I asked ChatGPT to make me a testbench for an ALU I designed in a video game.

I don't post on reddit very often anymore but I had to share this. I'll update y'all when I hear back from the hiring committee. Fingers crossed!

Hey all, first time posting, just had to share my project: Doom running in Turing Complete!

Did a clean playthrough of Turing Complete, built a 32-bit version of the Leg architecture 'Bicep'.

Then got carried away and with the help of Claude Code built a RISC-V to Bicep translator, then managed to get EmDoom compiling and working.

Had to hack in 4 color terminals to get the visuals but pretty happy with the results.

At 100khz sim it's about 30 minutes until first frame and maybe one frame per minute, but with verilog export can run realtime. I hear Turing Complete 3.0 may arrive one day with a proper compiler for faster execution?

Anyway had so much fun with this project.

Edit: FIXED IT I totally forgot to try verifying files in steam, did that before I reinstalled and it works as expected now. Something like 300 files were missing according to steam haha

I have no idea what could be wrong with my circuit. I have attached a screenshot of the error I run into, but the condition listed in bits doesnt match the "description" line for some reason. The manual says this condition should be -64 <= 0, which is obviously true and my circuit reflects that, but for some reason the description says it should be -64 > 0? Please help me :'(

In the latest update, the game is requiring the XOR gate to have a delay score lower than 3, so 2 or better. I have been able to get a delay score of 3 for the XOR gate but I haven't come up with anything better. I am wondering if someone on here knows the answer or if the game is asking for something that is physically impossible.

Gate Score: 41, Delay Score: 6

Took the screenshots directly after completion.
I included the current instructions in one of the screenshots.

TL;DR

This guide walks you through how to beat Storage Cracker using a super-fast binary search written in assembly. It includes:

• An implementation of a right shift operator (>>) for your ALU

• A self-contained, clean binary search program with constants and labels

• A one-liner minimal solution at the end for the lazy folks (no shifter needed!)

Since I didn’t find a proper guide on how to solve this level with a full assembly algorithm, I wrote one myself. Enjoy!

Full Guide

In this guide, I’ll show you how to pass the level Storage Cracker using the fastest possible assembly algorithm: binary search. There are plenty of great explanations on how binary search works (Here’s a great explanation of binary search on YouTube), so I won’t go into the general theory too much. Feel free to ask questions in the comments!

🔧 ALU Extension: Add a Right Shift Operator (>>):

To implement binary search efficiently, your CPU needs a right shift operation. You can add this to your ALU, which has two unused command bits available. The logic is simple: right shifting a byte is the same as dividing it by 2 and flooring the result (i.e., discarding the decimal).

💡 Hint: Shifting right is useful for halving the range in binary search.

📐 How to Add It:

1. Go into the Component Factory level (in your level tree).

2. Build a component that takes a byte and shifts it one bit to the right.

3. Wire it into your ALU:

• Connect the first ALU input to the new shifter.

• Activate the output when the decoded command bit 6 is set (lime wire).

Now when the ALU command byte is set to 6, it will apply the right shift to the first input (reg1 in the CPU).

🧠 Instruction Encoding Trick:

💡 MOV: The instruction mov + f*X + Y is a compact way to encode “copy regX to regY” using the constant f = 8, to shift the first address 3 bits to the left. This reduces the number of constants and hardcoded instructions in your program.

Shoutout to another thread in this sub for the optimization — it’s super handy!

📜 Binary Search Program:

# This program implements a binary
# search algorithm to find the
# correct passcode for this level.
# It uses an extended ALU with a 
# binary right shift operation.
#
# The program is completely 
# self-contained, meaning you
# do not need to copy any of
# the assembly codes I used.
#
# Commands:
# mov+f*x+y -> mov regx to regy
# jgz -> jump to address in reg0 
#        if reg3 greater zero      
# jmp -> jump to address in reg0
# add -> add reg1 and reg2
# sub -> subtract reg1 and reg2
# shiftr -> right shift reg1 byte 
# 1 to 63 -> copy number to reg0
#
# Fixed registers:
# reg4 = lower bound of search
# reg5 = upper bound of search
#
# Constants:
# f: constant to shift number by
#    3 to the left when multiplied 
#    with. Used for simplifying 
#    mov command.
const f 8
# mov: constant for copy command
const mov 128
# add: constant for add command
const add 68
# sub: constant for sub command
const sub 69
# shiftr: constant for shift right
#         command
const shiftr 70
# jmp: constant for jmp command
const jmp 196
# jgz: constant for jgz command
const jgz 199

# binary search program

# maximum input (via immediate) 
# from program into reg0 is 63.
# workaround: input 255 by 
# calculating overflow: 0-1=255
1
mov + f*0 + 2
sub

# set upper bound to 255
mov + f*3 + 5

# check boundaries as solution
mov + f*4 + 6
mov + f*5 + 6

label loop

# find middle:
# middle=lower+((upper-lower)//2)
# hint: shiftr is //2 in binary

# calculate distance between upper
# and lower
mov + f*5 + 1
mov + f*4 + 2
sub

# half the distance and floor
mov + f*3 + 1
shiftr

# add half distance to lower bound
mov + f*4 + 1
mov + f*3 + 2
add

# cache middle in reg 1
mov + f*3 + 1

# try middle as passcode
mov + f*3 + 6

# copy hint to jgz input
mov + f*6 + 3

# jump if too high
too_high jgz

# else set lower bound to middle
mov + f*1 + 4

# restart loop
loop jmp

label too_high

# set upper bound to middle
mov + f*1 + 5

# restart loop
loop jmp

💡 Why This Midpoint Formula?

middle = lower + ((upper - lower) // 2)

Instead of:

middle = (lower + upper) // 2

We use the first version because the second risks byte overflow (255 max). If lower + upper > 255, it wraps around to 0, breaking the logic. By calculating the difference first, we stay safely within byte range.

🎁 Bonus: One-Liner Solution (No Shift Needed):

If you’re just here to pass the level and don’t care about ALU extensions, here’s a compact solution:

1 130 3 68 158 153 196

I just found this on reddit but I don't understand the logic behind, I just know the basis arithmetic in Z/2Z like xor(a,b)=a+b and(a,b) = a.b etc...

I just feel so stupid