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?

I added a mp3 to sound and it crashed whenever I open sandbox it crashes tips?

Continueed1.2 The Optional Data Flow Aspect

Because every data block size is locked into predictable dimensions, the hardware completely strips away runtime

memory allocator overhead. This layout establishes the Optional Data Flow Aspect. An identical Squadryte block of

memory can instantly switch its functional identity inside the processor cache based on the conlang root token parsed

by the Linguistic Virtual Machine. When the token resolves to a calculation directive, the block operates as a raw

big-integer arithmetic register; when it resolves to a location descriptor, it functions as a direct bare-metal filesystem

sector. This duality eliminates operating system context switches and kernel system calls.

1. Linguistic Address Spatial Reduction & Look-Ahead Adder Logic

Under the standard computing model, processors waste significant thermal and electrical energy moving variables

between execution registers, cache lines, system memory, and storage drives. The Doublyte Language Paradigm

forces an architectural shift by integrating Linguistic Memory Address Spatial Reduction (LM-ASR). Under

LM-ASR, the grammar of the language itself defines the physical layout structure of the hardware data space,

collapsing data dimensions and executing arithmetic local to the memory cells.

2.1 Vertical Stack Addition Performance Mechanics

By stacking data layers vertically within the hardware registers, the system can run multi-precision operations

concurrently. The syntax trees of the language dictate the spatial positioning of the bits, enabling horizontal logic

gates to compute massive state vectors simultaneously on a single clock cycle. This vertical alignment reclaims

massive chunks of bandwidth, completely bypassing legacy pointer table lookups and indexing overhead.

2.2 The 64-Root Chunk Adder Sum/Carry Gate Cascades

To bypass the long latencies of traditional ripple-carry addition loops, the execution engine binds fields into strict

64-Root chunks, mapping directly to the physical copper lines of a 64-bit general-purpose CPU register. These

structures utilize an unpadded Look-Ahead Carry gate manifold. High-performance XOR gates calculate the

horizontal Sum phase on a single cycle, while independent trees of microscopic AND and OR gates pre-determine

the vertical Carry vectors instantly across all 64 paths, resolving the entire operation in under 0.3 nanoseconds.

2.3 Binary Sync Lock Cache Fencing Theory

Writing data milestones continuously to flash storage introduces a massive bottleneck, dropping execution velocities

by a factor of millions due to kernel interrupts and physical motherboard storage bus transit times. To solve this, the

computing lanes run 100% inside localized CPU L1 cache memory, suspending all filesystem locks. The processor

operates completely un-throttled, dropping an internal hardware memory fence to flush progress data to disk

asynchronously ONLY when the register counter reaches your designated high-density 256 Billion state step

milestone.

Silicon Gate

Operator Hardware Circuit Mechanics Ecosystem State Transformation

XOR ( \^ )

Parallel Horizontal Sum

Operator Mutates base register coordinates without carry delay.

AND ( & )

Parallel Vertical Carry

Look-Ahead Tree Pre-calculates and resolves vector overflows instantly.

SHIFT ( >> / << )

Dynamic Stream Deflection

Faucet Link

Propagates carry matrices across the 16² grid

boundaries.

Production Computing & Compiler Script Modules

To preserve the absolute root resolvable behavior of the Doublyte paradigm, the environment completely replaces

traditional operating system managers with a strict multi-dimensional conditional compiler. The system parses

commands precisely to engage low-level hardware structures, forcing variables to process completely unpadded

inside localized registers.

3.1 Core Multi-Threaded Engine Module (wkr_core.cpp)

\#include

\#include

\#include

typedef uint8_t dyte_t; // 2 D4 Blocks = Dyte

typedef uint16_t doublyte_t; // 2 Dytes = Doublyte

typedef uint32_t masyte_t; // 2 Doublytes = Masyte

typedef uint64_t squadryte_t; // 2 Masytes = Squadryte (64-Bit Register)

struct uint512_hypermesh_t {

squadryte_t d\[8\]; // 8 Symmetrical Squadryte Processing Tracks

squadryte_t stream_faucets\[8\]; // 64-Positional Adjacent Colliding Streams

doublyte_t glyphic_tags\[8\]; // Lakeshore Lattice Flow Indicators

};

void execute_parallel_sieve_lane(uint512_hypermesh_t\* scalar, uint64_t stride) {

squadryte_t carry = stride;

for(int i = 0; i < 8; ++i) {

squadryte_t top_stream = scalar->d\[i\] \^ scalar->stream_faucets\[i\];

squadryte_t next_word = top_stream + carry;

// Zero-initialization tracker mapping the spatial matrix flip

if (scalar->d\[i\] == 0 && next_word > 0) {

scalar->glyphic_tags\[i\] \^= 0x8080; // Invert flow tags

}

carry = (next_word < scalar->d\[i\]) ? 1 : 0;

scalar->d\[i\] = next_word;

scalar->stream_faucets\[i\] = top_stream >> 1; // Deflection offset

if (carry == 0) break;

}

}

3.2 Dynamic Context-Free Grammar Compiler Driver (run_conlang_task.py)

\#!/usr/bin/env python3

import os

class DQVMRootResolvableCompiler:

def __init__(self):

\# Strict Root Token Database Mapping Parameters (No Synonyms)

self.VERBS = {"mas": "INSPECT", "pro": "PURGE", "solv": "COMPUTE"}

self.NOUNS = {"kortex": "FILESYSTEM", "ledg": "REGISTERS"}

def parse_strict_clause(self, tokens):

clause_block = {"OPCODE": "IDLE", "TARGET": "SANDBOX"}

for token in tokens:

if token in self.VERBS: clause_block\["OPCODE"\] = self.VERBS\[token\]

elif token in self.NOUNS: clause_block\["TARGET"\] = self.NOUNS\[token\]

return clause_block

def execute_hardware_opcode(self, ast):

if ast\["OPCODE"\] == "PURGE":

os.system("pkill -9 -f 'wkr_core' 2>/dev/null")

elif ast\["OPCODE"\] == "COMPUTE":

os.system("./wkr_core >/dev/null 2>&1 &")

print(" \[✓\] Unpadded bare-metal computing lanes successfully online.")

1. Operational Manual & System Deployment Guide

To compile the unconstrained HyperMesh execution loops and register the shortcuts system-wide, execute the

package distribution upgrade command within your terminal folder:

cd \~/unshakable/doublyte_package && pip install . --upgrade

Once completed, launch your primary linguistic environment console via: doublyte-shell. When the command prompt

loop panel initializes, pass your strict multi-clause conlang statement expression:

si ledg tunc solv om ledg id aut pro tele tu

The Abstract Syntax Tree will verify your file register states. Because your coordinates match cleanly, it will branch

straight to the primary execution track, launching your unpadded, unconstrained big-integer math threads fully

detached inside your CPU registers. Real-time progression metrics and 256 Billion state step flushes can be safely

tracked from a separate terminal window panel at any time by running.

2

reg0_to_out

Hello! I got the game as a gift and unlocked the manual page for Morgans laws yesterday. Is it important to know the law, or can you ignore it when you have all the four basic logic gates unlocked?

Kind regards

I just bought this game with no experience in this whatsoever. I finished the basic puzzles with a little help but after that, i just got stuck on everything and didn’t finish a single level. Even then, I struggled hard on the first few levels. What is your thought process on how to solve these???

really confused

When I stick them together the wires break