Turing Complete — 2.1 progression guide: the campaign order, the scoring maths and the traps

Turing Complete is a 93-level puzzle campaign that walks you from a bare NAND gate to a working CPU you program yourself. This guide is the progression order chapter by chapter, the exact formula the game scores you with, the fixed gate/delay cost of every component you will build the campaign out of, and the handful of mistakes that cost new players their first ten hours.

Everything numeric below is sourced — the game's own score server, the developer's patch notes, the official instruction-set-spec repository, the community wiki, and the two living 2.1-era community guides. Where a number could not be sourced it is left out or flagged as unverified in Sources.

What "current version" means here

• This guide is written for 2.1 — the current release line. The 2.1 community solution guide I used

for the campaign order states it is "updated to 2.1.344" (that guide was last updated 29 September 2026, two days before this page).

• 2.0 landed on 15 July 2026 and was a ground-up rewrite: Godot was replaced with the developer's own

engine, all levels and all components were reimplemented, the 1.x LEG architecture was replaced by the newer Symphony architecture, components became variable-width (2–64 bits), a new assembler and compiler arrived, simulation got about 100× faster, and an in-game hint system that shows hints and solutions for every level was added.

• 2.0 broke saves. The developer's pre-release post is explicit: saves from the old version are

incompatible with the new one. If you are mid-campaign on 1.x, Steam → right-click the game → Properties → Betas/Channels → old_version keeps you on the pre-rewrite build.

• The community wiki is mostly a 1.x artefact. Its level pages still describe LEG-era levels

(Immediate Values (Leg), Level/Saving_Gracefully, Level/Robot_Racing), and its component pages predate the 2.x cost rescale. Its Game updates page and its 2.x-known-issues pages are current; its level walkthroughs are not. Do not follow a wiki level page for 2.1 without checking the name in-game.

The campaign at a glance

The 2.1 guide's index lists seven chapters and 93 levels. Chapter sizes and the gate-teaching each one delivers:

Two naming warnings before you read the lists. The English names below are quoted from the 2.1 guide, which pairs each in-game Chinese name with an English one. Where a level is scored, its name matches the official leaderboard's own name for it (byte_adder, byte_less_u, symphony_alu, maze, circumference, nim, capitalize, tower, rng, mod_4 and more), which is as close to a first-party check as exists. A handful of unscored levels (Second Cycle, Odd Cycles, Double Detection) have no official name to check against, and the wiki's 1.x pages use different names for what is probably the same slot (Second Tick, Odd Ticks, Double Trouble). Note also that 2.1 renamed at least two levels that 2.0-era guides call otherwise: 2.0's Input Selector is 2.1's Multiplexer, and 2.0's Byte Or is 2.1's Byte NAND (the official level slug byte_nand exists; byte_or does not).

Chapter 1 — Boolean Logic (13 levels)

1. Humble Beginnings
2. NAND Gate
3. NOT Gate
4. AND Gate
5. NOR Gate
6. OR Gate
7. Always On
8. Second Cycle
9. XOR Gate
10. Bigger OR Gate
11. Bigger AND Gate
12. XNOR Gate
13. Logic Exam

This chapter is cheap to do perfectly and expensive to do sloppily, because (§ below) the score you take on a component level becomes that component's permanent gate/delay cost. The world-best values here are tiny and reachable: NOT Gate 1 gate / 1 delay, XOR Gate 3/2, Bigger OR and Bigger AND 2/2 each, XNOR 3/2. A NAND-only XOR costs 4 NANDs (that is also an achievement).

Chapter 2 — Arithmetic, Memory (26 levels)

1. Binary Racer
2. Double Detection
3. Odd Number of Signals
4. Circular Dependency
5. Counting Signals
6. Half Adder
7. Delayed Lines
8. Double the Number
9. Full Adder
10. Odd Cycles
11. Bit Switch
12. Byte NAND
13. Byte NOT
14. Adding Bytes
15. Bit Inverter
16. Negative Numbers
17. Multiplexer
18. Signed Negator
19. The Bus
20. Saving Gracefully
21. Saving Bytes
22. 1 Bit Decoder
23. 2 Bit Decoder
24. 3 Bit Decoder
25. Little Box
26. Counter

Two structural notes. Little Box can be solved with a custom component — the 2.1 guide's tip is to unlock The Foundry (chapter 3) first, come back, and build it out of parts you already trust. And Binary Racer is the level that gates a skill-based achievement: the guide's advice is to use a calculator's programmer mode for round 7 and not to enable the accessibility option that turns the race timer off.

Useful reference figures for this chapter, all from the game's own score server: Half Adder 3/2, Full Adder 7/4 (28 energy), Byte NOT 8/1, Byte NAND 8/1 — a byte-wide NOT is one gate per bit with delay 1, so 8/1 is the arithmetic floor and the leaderboard sits exactly on it. Adding Bytes is where brute force first hurts: the free Full Adder the level hands you pins every input→output path at its worst delay, and the 2.1 guide measured the consequences directly — Adding Bytes comes out at delay 32 with the level's own adder versus 18 with an XOR-based one, and Unsigned Less 33 versus 19. That single substitution is a ~1.8× score penalty, and it is entirely avoidable.

Chapter 3 — CPU Architecture (10 levels)

1. Arithmetic Logic Unit (ALU) 1
2. Registers
3. Arithmetic Logic Unit (ALU) 2
4. The Foundry
5. Instruction Decoder
6. Conditions
7. ALU
8. Immediate Values
9. Program
10. Turing Complete

The Foundry is the custom-component editor: from here on, every reusable part you build can be boxed, named, pinned, and reused anywhere (and its cost in every later level is the score you earned building it). Immediate Values and Program are where your machine stops being a calculator and starts being a computer — the second of those two is followed by the level named Turing Complete, which is the chapter's (and arguably the campaign's) traditional milestone: a CPU of your own design executing stored programs.

Chapter 4 — Programming (7 levels)

1. Punchcard Programming
2. Assembly Programming
3. Circumference
4. Conditional Jumps
5. Code Breaker
6. Mod 4
7. The Maze

Punchcard Programming is the low-level introduction — you feed the machine raw words. Assembly Programming unlocks the 2.x assembler, and from there the puzzles are ordinary programs: read inputs, branch, write outputs. The two "gimme" scores are instructive: Assembly Programming's world-best energy is 13,805 gates / 4 delay for the pair Punchcard Programming + Assembly Programming, and Mod 4's world-best is 0 gates / 0 delay / 1 cycle — a direct output-mapping solution that uses no logic at all. The Maze's best is 6 gates / 5 delay / 373 cycles (11,190 energy). Cycle count is a first-class score axis in these levels, so hard-coding a path beats computing one.

The instruction set in chapter 4 is small and readable. From the 2.1 guide's own listings, the assembler accepts immediate loads and moves (imm, mov), the ALU operations (add, sub, and, xor, lsl, lsr), comparison and branching (cmp with je, jne, jb, jz, jnz, plus unconditional jmp), IO (in, out) and later memory forms (push, pop, load_16, store_16, pstore, pload with a stack pointer register sp). Labels are plain identifiers followed by a colon, and a jump to a label is written as an immediate. A complete, working Circumference solution from that guide — sum three inputs — is:

mov r1, in
mov r2, in
add
mov r1, r3
mov r2, r3
add
mov r1, r3
add
mov out, r3

Chapter 5 — CPU Architecture 2 (26 levels)

1. Hex Racer
2. Byte Constant
3. Byte XOR
4. Equality
5. Unsigned Less
6. Signed Less
7. Count Leading Zeroes
8. LSR
9. ASR
10. One Hot Encoding
11. Symphony Counter
12. Instruction Decoder
13. Comparison Flags
14. Symphony ALU
15. Wire Spaghetti
16. IO
17. Integrating ALU
18. Immediates
19. Condition Match
20. Jumps
21. RAM
22. Persistent Memory
23. IO Devices
24. Instruction Aliases
25. Stack
26. Functions

This is the long haul and the chapter that separates a 2.1 machine from a 1.x one. Where chapter 2 asked for byte-wide primitives, chapter 5 asks for word-wide ones at a delay budget: the 2.1 guide's own targets are Count Leading Zeroes delay 4, LSR and ASR delay 3, Comparison Flags delay 7, Symphony ALU delay 11. World-best energies from the official server: Equality 31/5, Unsigned Less 41/6, Symphony ALU 1,664/10 (16,640 energy).

The middle stretch is literally about wiring: Wire Spaghetti is the level where a clean component library pays for itself, and Integrating ALU / Immediates / Condition Match / Jumps together turn your ALU into an instruction decoder that consumes the ISA you are about to implement. The tail adds storage and the calling convention. The community wiki documents the game's own level files for this stretch — campaign/symphony_6_ram/meta.txt assigns opcodes 0 load_8, 1 load_16, 2 load_32, 3 reserved, 4 store_8, 5 store_16, 6 store_32, and campaign/symphony_7_ssd/meta.txt extends them with 3 pload and 7 pstore — which tells you both the shape of the level and how far up the ISA the campaign intends you to go (8-, 16- and 32-bit accesses, plus persistent loads/stores).

Chapter 6 — Programming 2 (7 levels)

1. Objective Beauty
2. Fast Symphony
3. Nim
4. Random Number Generator
5. Capitalize
6. Delicious Order
7. Tower of Hanoi

These are the showcase programs, and they are also where the score axis flips: a mid-campaign CPU that gets the right answer can be five orders of magnitude worse than a tuned one. On Circumference the world-best energy is 128 (32 gates × 4 delay × 1 cycle) while a 98%-complete player's build on the official site scores 18,604,272 (14,626 × 106 × 12) — a ratio of about 145,000×. On that level the leaders sit at 32/4/1; the next entries are 33/4/1 (132 energy) and 35/4/1 (140), while one player takes 29 gates at delay 5 (145). The gap is not effort, it is CPU design: fewer cycles means fewer instructions means a better ISA.

Fast Symphony is the level that explains the compounding rule out loud. The 2.1 guide's method is to rebuild the XOR used in your Full Adder with a delay of 2, set the Cost of your XOR / add / less-than components to minimum delay, and then re-solve and overwrite earlier levels (Full Adder, Unsigned Less, Signed Less, Symphony Counter, Comparison Flags, Symphony ALU) so the library itself gets cheaper. The level then checks you against these delay figures:

Chapter 7 — Optional component levels (4 levels)

1. Multiply
2. Divide
3. Modulo
4. Overture

These sit outside the main line and are worth doing for the components alone (a multiplier and divider in your library is what the achievement 7 Adder Multiply is about). Overture is the score-chasers' level: the 2.1 guide's author, asked about its requirements in the comments, answers that Overture has no requirement and exists for players hunting the leaderboard — which is the honest description of the architecture-level scores you see on the official site.

How the score is calculated

The official leaderboard states the rule for your overall rank: "Your overall score is the log2 of energy cost for each level, added together", so halving any level's energy costs you exactly one point. Energy itself is:

• Component levels: energy = gates × delay, where gates is the sum of the gate cost of every

component in your schematic, and delay is the longest input→output path through it — the bottleneck path. A byte NOT is one gate per bit at delay 1, hence 8/1.

• Programming levels: energy = gates × delay × cycles, where cycles is the worst-case cycle count

over the level's test cases.

I checked that formula against the game's own published numbers rather than taking it on faith. Four rows of the official site, re-multiplied:

I ran the same arithmetic over every row on two profile pages (the rank-1 player and a 98%-complete player, 60-plus level scores) and it held in every case, including the zeros — Mod 4 at 0/0/1 really is 0 energy. Note the consequence for campaign planning: in a component level cycles are 1, so only the gate×delay product matters, but in a programming level a lazy program can outweigh a beautiful circuit.

Fixed gate and delay costs in 2.1

Most of what you build is made of a small set of components whose costs you cannot change. The 2.1 score-optimisation guide tabulates them:

Two things follow. First, wiring is free and memory is not: a hub or splitter costs 0/0, while a 1-byte SRAM costs 50 gates before you have stored anything. Second, the orange-pinned components (delay lines and the read ports of pipelined RAM) need a clock cycle to respond, and their delay is counted on the path leaving their output, not the path entering it — which is exactly why they are the classic source of "my circuit works but is one tick late" bugs.

These figures are one generation removed from the 2.0-era change log, which lists the new costs for the basic parts as gates/delay 1/1 for AND/OR/NAND/NOR/NOT (1/2 in 1.x), 2/1 for the bit switch (1/2 in 1.x) and 5/0 for the bit delay line (1/0 in 1.x). The 1/1 and 2/1 values agree with the 2.1 numbers above and with the leaderboard minima; the delay line's delay does not (5/0 vs 5N/4) and I could not reconcile that, so treat the delay-line delay as the one figure here to check in-game.

What a good score looks like

World-best values read off the official leaderboards on 1 October 2026:

None of these are hidden tech: they are what the front page of the game's own score server shows. If your Full Adder is 7 gates at delay 4 and your Adding Bytes is under about 500 energy, you are at competitive level, and the rest of the campaign is downhill.

Fast adders: the formula that beats brute force

The one piece of theory that most improves a 2.1 score is the parallel-prefix adder, and the 2.1 optimisation guide gives the closed forms. For a 2^N-bit addition:

For 8-bit addition (N = 3) that is 255 gates and 255 delay for a ripple-carry chain versus 21 gates at delay 5 for Brent–Kung — the same circuit, two orders of magnitude apart on both axes. This is the difference between a campaign that ends in chapters 4–6 and one that ends in chapter 3.

The traps

1. Your early score is your permanent component cost. A component's gate/delay cost is fixed by the

level in which it was unlocked, so a 6-delay XOR contaminates every adder you build afterwards. Fix it early, or use the Fast Symphony trick and overwrite the old level solutions with cheaper ones.

1. Never accept the level's bundled components at face value. The Full Adder handed to you in Adding

Bytes sets every path to its worst delay; using it doubles the delay on that level (32 instead of 18), and the same penalty reappears in Unsigned Less, Signed Less, Comparison Flags and the Symphony ALU.

1. Gates are the wrong dial after chapter 5. In programming levels cycles multiply into the score, and

they swing far harder than gate count: 128 versus 18.6M energy on one level. Optimise the ISA, not just the wiring.

1. Do not install 2.1 over a half-finished 1.x campaign. The saves are incompatible. Park on the

old_version channel or start clean.

1. All programming levels share one circuit file. The 2.1 guide warns you to create a new file for

each one, or a level-specific hack will land on top of your general-purpose machine.

1. Orange pins cost a cycle. Delay lines and pipelined RAM read ports respond on the next tick and

their delay is charged on the outgoing path. Budget for it instead of debugging it.

1. Multiply and divide are optional but load-bearing for achievements; and for Little Box, unlock The

Foundry first and solve it with custom components instead of from scratch.

1. Throw away every pre-2.0 guide's opcodes. Older walkthroughs teach LEG and hand out numeric

instruction encodings (ADD = 68, SUB = 69); 2.1's assembler takes mnemonics and its architectures are Overture/Symphony. If a guide says "LEG", it is describing a game you are not playing.

1. Read the in-game hint system before you suffer. As of 2.0 the game ships hints and solutions for

every level; a stuck player now has an official answer available on the spot.

1. Small levels are tested exhaustively. The 2.0 notes say most levels of 16 bits or less are now

tested on every input, so a circuit that has not been reasoned about will fail rather than pass by luck. There is no fudging a truth table.

1. Memory has modes and ports you should use. RAM supports big- and little-endian layouts, a port

system that allows multiple loads and stores in the same tick, hex-editor and punch-card views, and a DRAM mode whose read delay is floor(128 ÷ pipeline depth) — deep pipelining is how you get cheap memory without a huge delay charge.

1. Scoring is unlocked by the campaign itself. The 2.1 score-optimisation guide asks readers to have

completed Objective Beauty (Programming 2) first, describing that as the point at which scoring is available — so do not expect to chase the leaderboard from chapter 1.

Sources

Read on 1 October 2026. Current version stated on the page: 2.1, build 2.1.344 as reported by the 2.1 solution guide's update note (29 September 2026). No Steam announcement accompanied the 2.x→2.1 move, and SteamDB's patch list refused my fetch (HTTP 403), so I could not read an official version history beyond the 15 July 2026 2.0 patch notes.

Official (game / developer):

• https://turingcomplete.game/ — official site
• https://turingcomplete.game/leaderboard — overall scoring rule (log2 of energy, summed)
• https://turingcomplete.game/profile/362 and https://turingcomplete.game/profile/100 — per-level

gates/delay/cycles/energy listings used to verify the energy formula

• https://turingcomplete.game/leaderboard/xor_gate, /full_adder, /byte_adder, /byte_less_u,

/symphony_alu, /maze, /circumference — world-best values

• https://store.steampowered.com/news/app/1444480 — Steam news hub; the posts used are *Turing Complete 2

patch notes* (15 July 2026), The story is back, the alien is out (27 July 2026), Breaking update upcoming (27 June 2026) and Turing Complete 2.0 status update (24 February 2025)

• https://github.com/stuffe/isa_spec — the developer's instruction-set-specification repository emitted by

the game itself; latest commit at time of writing is "Update from Turing Complete v2.1.315" (19 August 2026), and its spec_lib carries aarch64, aarch64_neon, risc_v and x86_64 definitions

Community guides (both in active use for 2.1):

• https://steamcommunity.com/sharedfiles/filedetails/?id=3496162641 — Turing Complete 2.1 Guide by

Ineffabilis: the chapter structure, level order, English level names, assembler listings, delay targets and the Little Box / Foundry and Binary Racer tips. Source of the chapter structure and level order above.

• https://steamcommunity.com/sharedfiles/filedetails/?id=3789887881 — 2.1 score-optimisation guide, same

author: the scoring definition, the fixed gate/delay table, the best-known per-level figures and the parallel-prefix formulae.

• https://steamcommunity.com/sharedfiles/filedetails/?id=3743901501 — *Turing complete - level guide

[OUTDATED] 2.0*, used only to confirm which level names changed between 2.0 and 2.1.

• https://steamcommunity.com/app/1444480/guides — the Steam guides hub the queue pointed at.

Community wiki (turingcomplete.wiki):

• https://turingcomplete.wiki/wiki/Game_updates — the 2.0 break list (engine replacement, LEG → Symphony,

level reimplementation)

• https://turingcomplete.wiki/wiki/Save_breaker_changes — the 2.x scoring change (gates × delay × ticks)

and the old/new cost table for basic gates, the bit switch and the bit delay line

• https://turingcomplete.wiki/wiki/Known_issues/2.0.16 — the campaign/symphony_6_ram/meta.txt and

campaign/symphony_7_ssd/meta.txt opcode assignments

• https://turingcomplete.wiki/wiki/Walkthrough and https://turingcomplete.wiki/wiki/Components — used to

confirm how much of the wiki is still 1.x-era

What I could not verify, stated plainly:

• These two figures carry the most uncertainty. The delay line is listed as 5/0 in the wiki's 2.0

change table and as [5N/4] in the 2.1 optimisation guide; I could not reconcile them, so the delay-line delay is the one number here to sanity-check in-game.

• Level names for unscored levels. Second Cycle, Odd Cycles and Double Detection come from the 2.1

guide's English list and have no official counterpart I could check them against; the wiki's 1.x pages (Second Tick, Odd Ticks, Double Trouble) may or may not be the same levels renamed.

• The wiki host refused direct connections from both networks available to me throughout this run, so

its pages were read through a web-extraction service and two of them (Save_breaker_changes, Known_issues/2.0.16) returned partially rendered, which is why quotes from those two are limited to what surfaced.

• Build number. 2.1.344 is the figure the 2.1 guide reports; the ISA repository's newest sync is from

v2.1.315. If the game has patched again since, the numbers above are unaffected (no cost change has been announced), but the version line will be stale.