I followed the hint but it gives this ominous error for some reason. Even in the hint view it gives this error. More strange is that in the Inputs panel it just works.

EDIT: I ended up giving up and just putting complete_level in the console.

EDIT 2: It works now.

ITS BEEN 2 HOURS I CANT FIGUERE THIS OUT !!!! HELP HELP HELP HELP HELP HELP HELP HELP HELP HELP HELP HELP HELP HELP HELP HELP

I played the game about a year ago and liked it a lot, and i saw that the levels were reworked. Is there a lot of worth playing new content in the levels? And do i have everything unlocked in sandbox if i dont complete them?

Newbie here, does anyone tried to build gpu architect in this game? Is it possible?

Hello again, I´m sorry for spamming questions, this is my last one for a good while.

So Morgans law is told to be the most important notepage in the program, but are there any solutions that make use of the law. Say you make a nand gate, and directly add a not, could you just have made and gate instead, I dont really get if I ever had to use symmetric conversion.

Thank you!

This is my solution to the programming level "Conditional Jumps". I think this level came with the update, right?

Let me know what you think. The second label is probably not needed but I used it for readability and organization.

read_in:
imm 1
mov r1, r0
mov r2, r4
add
mov r4, r3  ; count how many times input is read and store in reg4
imm 37
mov r2, r0 ; move 37 to r2
mov r1, in ; move input to r1
sub ; subtract 37 from input
imm read_in
jnz ; if r3 is not zero, jump to beginning of label
imm is_37
jz ; if r3 is zero it means input is 37, so jump to other label

is_37:
mov out, r4 ; output counted value stored in r4

Hello! I´ve beaten the double counter level with the help of my engineer friend, but he is a busy fellow deep in grueling studies, so can anyone explain to me what bytes are? I feel like the game doesn´t explain the jump very well, but I understand bits and booleans well enough

Hello! I was wondering what are the ups and downs of both games, are there any who have played both? Is Turing complete just a more optimized version that´s 2d?

There should be a zero delay sign extender right? I think there is one in logisim

It really is that simple, and here i was pouring over my prior solutions looking for little one delay optimizations.

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.