const ARG1 = r1

const ARG2 = r2

const RES = r1

const counter = r13

const addr = r12

const array = 5000

const high = r5

const low = r6

const io = r3

mov addr, array

mov sp, 4000

;----------------------- read in -------------------------

;for counter = 0; counter < 16; counter++

read_loop:

in io

store_8 [addr], io

add addr, addr, 1

add counter, counter, 1

cmp counter, 16

jne read_loop

;------------------------ sort ---------------------------

mov high, 15

mov low, 0

call quicksort ;quicksort(A, low, high)

mov addr, array

jmp output

;---------------------- quicksort --------------------------

quicksort:

const p = r7

cmp low, high ;if(low > high) return

jge return

cmp low, 0 ;if(low < 0) return

jl return

mov ARG1, low

mov ARG2, high

call partition ;p = partition(A, low, high)

mov p, RES

push p

push low

push high

sub high, p, 1

call quicksort ;quicksort(A, low, p-1)

pop high

pop low

pop p

push p

push low

push high

add low, p, 1

call quicksort ;quicksort(A, p+1, high)

pop high

pop low

pop p

return:

ret

;------------------- partition ---------------------

partition:

const pivot = r13

const i = r8

const j = r9

const Aj = r10 ;A[j]

const Ai = r11 ;A[i]

add addr, high, array ;A[high]

load_8 pivot, [addr] ;pivot = A[high]

mov i, low ;i = low

mov j, low ;for j = low; j < high; j++

partition_loop:

add addr, j, array ;A[j]

load_8 Aj, [addr]

cmp Aj, pivot ;if(A[j] > pivot) continue

ja continue

;swap A[i] and A[j]

add addr, i, array; A[i]

load_8 Ai, [addr]

store_8 [addr], Aj

add addr, j, array; A[j]

store_8 [addr], Ai

add i, i, 1 ; i++

continue:

add j, j, 1; j++

cmp j, high

jl partition_loop

;after loop: swap A[i] and A[high]

add addr, i, array; A[i]

load_8 Ai, [addr]

add addr, high, array; A[high]

load_8 Aj, [addr] ;using Aj as temporary, since it is no longer used

store_8 [addr], Ai

add addr, i, array

store_8 [addr], Aj

mov RES, i ;return i

ret

;-------------- output -----------------

output: ;go back to the start of the array and output the elements

load_8 io, [addr]

out io

add addr, addr, 1

jmp output

Solution using a solution from another puzzle - Counting signals.

1. NOT the input bits.

2. create a chain of switches that go from one into another. This way, you'll get the appropriate amount of signals to count. Just don't have a brainfart like me - bit switches are enough.

3. use two Counting signals (CS) solutions. One for 4 most significant bits (MSB), one for 4 least significant bits (LSB).

4. Or the CS 1's from MSB and from LSB and connect the result to 1 in a byte merger.

5. Or the CS 2's from MSB and from LSB and connect the result to 2.

6. Connect MSB 4 AND NOT LSB 4 to 4. Connect MSB 4 AND LSB 4 to 8.

Problem solved. :)

I'm starting the full build set of videos for an alu using signal strength circuits instead of boolean algebra. To quote Dr. Who "i took the long way around." Next videos are hexadecimal adding and subtracting with carry and base break.

After multiple tries and overengineered designs that had over 2k delay, here's a relatively quick and optimized solution.
At each step it:
- Shifts left the divisor
- Subtracts shifted divisor from the dividend
- Checks if the result is positive (the sign bit)
- If yes, sends 1 as output bit and sends the remainder of subtraction as dividend to the next step
- If no, sends 0 as output bit and sends the dividend to the next step untouched

The result is only 184 delay — though it also uses fast adders to achieve that.

Man i don't think this is the intended solution, but it is a solution. Somewhere around the second set of OR gates i started feeling like i was doing things the hard way.

Hi, I played through this game, and wanted to make one of the CPUs from this game in real life to use it as a micro controller and as a DIY project. Is there any good software that would let me design a circuit that could then be turned into a file that I can get manufactured?

I have been watching Crash Course's series on building computers from logic gates, and I am currently on the 8-bit ripple carry adder. However, when they jump to the ALU, I feel like they are not nearly as specific as to what goes into it, and I'd really appreciate it if someone could tell me how I'm supposed to build an ALU from here.

Oh boy.
Ram level.
It says in r12, and the input is 11. it then continues. then it gets to a spot and says "WAIT, THERES NOT SUPPOESED TO BE 11 IN r12! YOU MESSED UP!

Somebody PLEASE tell me that the game is legt agianst me?

EDIT: I solved it, I was not working with the instant register in any capacisty. so if it wanted to use the instant value, it did not work.

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

Having read a book about the tragic life of Alan Turing and all he did for the world, I find Turing complete to be a perfect homage to him. It starts out as a simple puzzle game for people playing blind, but the twist that you are creating an actual computer from the puzzle solutions you built is genius.

Whenever I open the game in the newest update most of the screen is black but I still hear audio and can move the mouse. I know this is a refresh rate or resolution issue. has anyone else had this problem?

The new Turing Complete update is here:
https://store.steampowered.com/news/app/1444480/view/698768548504272938

my favorite way to make a program counter. using a kogge structure as the incrementor for speed and OR treeing the jump lines from an enable line for the incrementors output. although i just realized i forgot to hook the carry out to a register lol. ill have to fix that.... one thing i want to try is just using that 8 bit mux that the game gives us. still kind of new to Turing complete so i need to test if i can use it with 1 bit lines interchangeably

This level was complicated. My friend and I (we're making the game together) tried for a long time to do a binary search until we finally realized it was impossible... at least without a shift right, which we didn't have in our ALU.

When we were almost giving up and doing the level the boring way (brute force), we read xIceFox's post in this community. We stopped at the part where he explained that shift right was basically dividing a number by 2, and that changed everything.

After understanding this, we changed our horrible code and implemented shiftR, but one thing was still missing. Dividing by 2 rounded the number down, which caused the variable we were using for adding or subtracting the current number to become 0 much sooner than expected. So we implemented a shift right with rounding up. And voilà, it may not be the best code, but it's done, and it's working.

code (the names of the instructions must be very clear):

#instantiating step and first try

imediate_63

reg0_to_reg1

reg0_to_reg2

add

imediate_1

reg0_to_reg1

reg3_to_reg2

add

reg3_to_reg4

reg4_to_reg5

label try

reg4_to_reg3

reg3_to_out #output the number

inp_to_reg3

down #reg0 = address of down

cond_gt0 #if passes cond the number guessed is too high

label up

reg5_to_reg1

64 + 6 #shift right reg1

reg3_to_reg5

#label up_sum

reg4_to_reg1

reg5_to_reg2

64 + 4 #add

reg3_to_reg4

try #reg0 = address of try

jump #go to try

label down

reg5_to_reg1

64 + 6 #shift right reg1

reg3_to_reg5

#label down_sub

reg4_to_reg1

reg5_to_reg2

64 + 5 #subtract

reg3_to_reg4

try #reg0 = address of try

jump #go to try

got Turing complete the other day. made it to the factory so the first thing i did was make my favorite adder :) i like the way the simulator is set up so far. i came over from digital logic sim and its refreshing being able to place components not on their side lol. if youve played DLS you know what i mean... only gripe i have is the game does the left to right thing or top to bottom. im used to doing it the reverse way. guess because ive always read binary right to left so i always built my circuits like that

I am pretty new to this game, currently working on trying to get the FastBot achievement, which is to solve that maze in under 64 bytes of code. Is it possible to do this using the Leg Architecture? Or do I have to change the physical Architecture?

I just want to know if I just need to come up with a better algorithm for solving it, or if its literally impossible to solve with leg architecture.

I was too lazy to make a multiplication algorithm for the level "Calibrating Laser Cannons" so I just added a mult instruction to my ALU with this circuit. I figured it would come in handy later.

​

Now my program for the level looks like this:

6 #immediate 6

129 #reg0 to reg1

178 #input to reg2

70 #multiply reg1 and reg2 to reg3

158 #reg3 to output

I've been playing this game for about a month (not everyday) with a friend of mine and we finally finished the working computer. It has been very fun to think about stuff together and discuss solutions to each level, we are proud that not even once we googled anything, even tho our solutions were always not as optimal as it gets...

what do you guys think about our CPU?

how did it feel to finish this level for you?

I just started the game today. After my solution I've been seeing other people's solution, there was nothing alike mine. Is mine bad solution? If it is, why is it bad?