IT THINKS! is 62 handcrafted contracts spread across six eras. Each era adds one layer to the machine you are building, and each one fails for its own reason. This page maps the campaign so you know which layer you are actually stuck on — and the fixed order to check when a circuit refuses to work.
One honest caveat first: this is a structural walkthrough, not a list of per-contract answers. The game already gives you optional hints, short concept lessons, a Master's Notebook and the ability to skip tests you can pass, so what is genuinely missing while you are stuck is usually not more hints — it is knowing which layer is broken.
The shape of the campaign
The eras are a chain, not a menu. Arithmetic becomes the parts list for memory, memory becomes the parts list for the processor, the processor becomes the parts list for parallel cores, and the cores become the parts list for the matrix pipeline that ends up as a GPU.
That chain is why being stuck in era four is often a problem you created in era two. If your adder chip is wrong, the processor that uses it is wrong in a way no amount of debugging at the processor level will reveal.
Era 1 — one logic gate
What you are building: everything out of a single NAND gate. Two inputs, one output, and the four-row truth table that governs all of it.
The usual blocker: thinking you need to be handed an AND gate. You do not. NAND is complete — NOT, AND, OR and XOR are all NAND arrangements, and once you internalise that, the whole era opens up.
How to get through: build the four gates (NOT, AND, OR, XOR) by hand before moving on, then cast each one as a chip. This is the single highest-leverage half hour in the campaign, because every later era draws on it.
Era 2 — arithmetic
What you are building: circuits that add. A half adder is an XOR plus an AND; a full adder chains two half adders and an OR; an ALU is a pile of full adders with control logic on top.
The usual blocker: carry handling, and bit width. Adding two single bits is easy. Adding eight bits means the carry has to ripple through every stage, and it is very easy to wire a carry into the wrong place and get answers that are right for small numbers and wrong for large ones.
How to get through: test with the bench, not with intuition. Run the smallest case that can carry (1 + 1), then the largest your width supports. If the answer is wrong only when a carry is generated, the carry path is the bug — do not touch the sum logic.
Era 3 — memory
What you are building: something that holds a value. That means feedback: a latch is two gates arranged so each one's output feeds the other's input, and that loop is the first place the game asks you to reason about state instead of signals.
The usual blocker: feedback loops that latch on the wrong edge, or a register that reads back what you did not write. Almost always this is timing — a write line that is still active while you are trying to read.
How to get through: prove the latch alone on the bench (set it, hold it, clear it) before you build anything that uses eight of them. Then prove one register, then two registers sharing an address line. Debugging a memory array that you never debugged at the one-bit level is the most common way to lose an afternoon in this era.
Era 4 — a programmable processor
What you are building: a machine that runs instructions — a program counter, an instruction decoder, registers, and the arithmetic you already built. The store page mentions a compact assembly language and writing kernels, which is exactly what this era unlocks.
The usual blocker: the instruction decode. A processor that does nothing is usually a processor whose control lines never fire; a processor that does the wrong thing is usually one where two control lines fire at once.
How to get through: write down the instruction set you actually built, one line per instruction, with the exact control lines it needs. Then run one instruction at a time and watch every control line, not just the output. This is also the era where casting pays for itself hardest: decode logic is reused by every instruction.
Era 5 — parallel cores
What you are building: more than one of the processor you just made, plus a way to feed them. The store page's framing — running the same kernel across several cores, with parallel efficiency as one of the trade-offs — tells you what the era is really about.
The usual blocker: a correct design that is barely faster than one core. That is a scheduling and bandwidth problem, not a logic problem: if every core waits on the same shared path, adding cores adds contention.
How to get through: measure one core's time first, then two. If two is not close to half, fix the shared path before adding a third. More cores on a starved bus is how you spend an era getting slower.
Era 6 — matrix multiplication and the GPU
What you are building: the actual goal of the game — the pipeline that makes a machine that thinks, ending in a chip that recognises the shapes you draw.
The usual blocker: scale. The design that worked at small width stops fitting, and every shortcut you took on area and depth shows up at once.
How to get through: this is an architecture problem, so solve it at the architecture level. Copy the multiply-accumulate unit across as a repeated chip, keep the routing regular, and go back and fix the one component with the worst area-to-work ratio before you add more copies of it.
The order to check when anything is broken
Whatever era you are in, dead circuits fail in roughly the same order. Check these five before you redesign anything:
- Inputs. Is every input actually driven, including constants?
- Outputs. Is the output you care about connected to something that watches it?
- Drivers. Is exactly one thing driving each net, or are two outputs fighting?
- Depth. Is the signal arriving too late for the clock or the read window?
- The layer below. Is the chip you are using wrong? Re-verify it on its own bench.
Number five is the one people skip, and it is the one that costs the most time — a broken cast chip makes every design that uses it wrong, and the design looks correct the whole time.
Beyond the campaign
Contracts are not the only loop. The store page lists client orders between contracts, a workshop that grows through nine tiers, daily puzzles with a leaderboard for the best designs, and community puzzles you can publish yourself. The free bench is where most people build the designs they are proud of: up to 4,000 parts, buttons, a keypad, seven-segment displays, a 16×16 light array, a buzzer and dice, all shareable as a link anyone can open in a browser.
If you are still on the first gate, read the NAND gate truth table. If your circuits work but the campaign still feels slow, the problem is usually that you are rebuilding instead of casting — see casting chips. And if you have not played yet, the browser demo is free.
FAQ
How long is IT THINKS!?
The store page lists 62 handcrafted contracts across six eras. There is no published hour count, and the honest answer is that it varies enormously with how much you build by hand versus license from the factory.
Can I skip contracts I am stuck on?
The campaign structure is sequential by era, but the game is generous with help: optional hints, short concept lessons, a Master's Notebook, and tests you can skip if you already know the material.
Do I need to finish the demo to keep progress?
No. The store page confirms progress carries over — automatically from the Steam demo, or with a save file from the browser demo.
What platforms is the full game on?
Windows, macOS and Linux, planned for 19 November 2026 on Steam. The system requirements list Windows 10 64-bit, macOS 11 or later, and Ubuntu 22.04.