Solve a Rubik's Cube with your eyes closed.

Here's the whole idea as a picture. Imagine a circle of friends, each holding a gift meant for someone else — everyone's got the wrong one. One person volunteers as the middleman: they hand their gift to whoever it belongs to, take whatever that person was holding, pass it to its owner, and keep going until their own gift comes back. Everyone ends up with the right gift — and the middleman only ever held one gift at a time.

A Rubik's cube is exactly this. Every spot holds one piece (like everyone holding one gift), and you solve it by sending each piece home through one fixed spot — the buffer, your middleman. The looping path the pieces follow is called a cycle.

Each swap is done by running an algorithm — a short, fixed sequence of turns you've memorized that always makes the same swap. The same sequence also drops the next wrong piece into the buffer, so you just repeat until every piece is home.

The whole skill is then four layers that build on each other: understand this method, learn its tools (reading the cube as letters, and the moves that swap a piece home), do a complete solve sighted — eyes open, nothing memorized — then add the one hard part last: memorizing the order and running it blind. We'll climb them in that order.

Two slots are special, and it's worth keeping them straight. The buffer is your hand — for edges the UR sticker (lettered B), for corners the ULB corner — the place you always shoot from (to "shoot" a piece just means to send it home with one swap). The swap spot is a second fixed slot (UL for edges) that the swap algorithm trades the buffer with. Every piece you solve is briefly brought to the swap spot, traded home, and put back — you'll see exactly how a few chapters down, in Setups.

So don't confuse the swap spot (a fixed trading post — always UL) with a piece's target (its own home, different for every letter). The buffer never gets a letter while tracing — it's where you shoot from, not to.

Every sticker gets a letter A–X (this standard scheme is called Speffz — just a name, nothing to memorize). Each face's four stickers are lettered clockwise; you go face by face. A piece has two (edge) or three (corner) stickers, so it carries two or three letters — one for each spot it could be read from.

You don't memorize the whole map up front. You just need to read the letter of the sticker you're pointing at, which the cube view shows you directly.

Reading a piece's letter is the skill of knowing where it goes — so drill that here.

Here's the core loop. Look at the piece in the buffer. Where does that piece belong? Go to its home slot — the target — and write down that sticker's letter. Now look at the piece sitting in that slot: where does it belong? Write that letter. Keep chaining.

Each letter says "shoot the buffer piece here." A chain of these is a cycle: buffer → A → B → C → … Each step solves exactly one piece.

A cycle closes when the chain points back at the buffer — the next piece you'd shoot is the buffer's own piece (for edges, the white-and-red piece that lives at UR; for corners, the white-blue-orange ULB piece). When the trail leads back to that piece, you'd just be putting the buffer home — so the cycle is done (not "I'm tired of this cycle"). The trace map shows it as ↩ closed, looping back to B.

The cube usually isn't fully traced yet, so you break in: start a new cycle on any still-unsolved, unvisited piece — the choice is free. You're finished only when no unsolved pieces remain.

The algorithms are written in cube notation, so you need to read it before the next two chapters. Hold your cube white up, green front. Each capital letter is a face you turn a quarter-turn clockwise: Right, Left, Up, Down, Front, Back. A ′ (prime) means turn it counter-clockwise instead; a 2 means a half-turn. So R U R′ is right cw, top cw, right ccw.

Setups also use wide turns, written with a small w — Lw and Dw. A wide turn turns the outer face plus the middle layer right beside it, as one block. (Primes and 2s work the same on wide turns — Lw′ is just the wide turn the other way.) That extra reach is exactly what lets a setup move a piece while leaving the buffer alone.

Now the moving tools. You learn just two algorithms. The T-perm swaps the edge buffer with the edge swap spot; the Y-perm swaps the corner buffer with its swap spot. That's the whole toolkit — every edge is solved with the same T-perm, every corner with the same Y-perm.

Both are in the reference panel below, broken into triggers — small, muscle-memory chunks like R U R′ that your fingers learn as one motion. The cube demo shoots a piece home with one swap so you can see what it does.

The two swaps are mirror images of each other. The T-perm swaps your buffer edge with the swap spot — but it also swaps two corners. The Y-perm swaps your buffer corner with its spot — and also swaps two edges. Each one cleanly fixes one pair in its own orbit (edges and corners are separate worlds — a piece never crosses between them) and borrows a pair from the other. Those borrowed pieces have to come back exactly where they were, which is the whole reason setups are restricted (next chapter).

Here's each one run on an otherwise solved cube — watch how few pieces actually move (and why a stray sticker pops up on top for the Y-perm):

But a swap only fixes one specific slot — the swap spot. To solve any other letter X, you first set up: a few turns that walk the piece belonging at X into that swap spot. Run the swap to send it home. Then undo the setup — the same turns, reversed — which walks everything you nudged back out, exactly where it started. So each piece is only ever temporarily brought to the spot, sent home, and the detour is erased.

The pattern is always setup → swap → undo. The undo is what makes it work: it puts the whole cube back the way it was, except the one piece you just sent home. The app knows the setup for every letter — watch one, then drill recalling them yourself.

This is the gift trade from chapter 1, made real. A perm is nothing more than an algorithm that effectively swaps two pieces — your buffer and the swap spot — exactly like the middleman trading with one spot. The clever bit is the setup: a few quiet turns that move just one piece into the swap spot so the trade can reach it. Move one cube into place, swap, move it back — and you've traded your buffer with any piece on the cube. Small algorithms that nudge a single piece, composed into a clean swap: that's the entire engine.

The catch — you can't use just any moves to set up. The swap algorithm also moves a few other pieces (the T-perm swaps two corners; the Y-perm swaps two edges) and counts on them returning to place across the whole solve. So a setup must not disturb those: edge setups use only L / Lw / Dw turns (never R, U, F or B), and corner setups use only D / F / R (never U, B or L). Those moves stay away from the buffer and the pieces the swap borrows. Anything a legal setup does touch, the un-setup puts back. Every setup here follows that rule and is engine-verified.

One last tool to recognize. Parity is an unavoidable leftover that shows up on some scrambles: when your edge trace has an odd number of letters, one pair of edges and one pair of corners end up swapped. The fix is mechanical — you run one parity algorithm once, between the edges and the corners, and it sorts out both (its moves are in the reference card just below the lesson, and Solve With Me inserts it for you) — but the skill here is just detecting it: finish the edge trace and count. Odd ⇒ parity, even ⇒ none.

Can you dodge it? Not by tracing differently — parity is baked into the scramble, not your choices, so you can't extend a cycle to make it disappear. But only about half of scrambles have it, and Solve With Me runs the fix for you automatically — so you may rarely (or never) type the parity alg by hand, even though it's quietly doing the work.

Now put the tools together — with your eyes open, memorizing nothing. Trace a piece, run its setup → swap → undo, watch it land, then trace the next and repeat. Run the parity alg once between edges and corners if your edge count was odd. Last piece home = solved cube.

This is a real solve — you've just kept your eyes open and skipped the memory step. Do it until the algorithms live in your fingers and the trace feels natural. Solve With Me walks you through a whole one, shot by shot.

The only thing left is to stop looking. Instead of tracing-and-executing one piece at a time, you trace the whole cube first and remember the order, then execute it from memory. A solve is ~11 edge letters and ~8 corner letters — raw letters slip away fast, so you pair them up: two letters become one vivid image (e.g. "GD" → a word starting G·D), and you string the images into a short, silly story. Edges are one story, corners another.

The real test isn't reading the memo — it's holding it. Drill the pairs into images, then practice recalling a whole memo after a delay.

Put the last layer on. Memorize: trace edges, then corners, into your two stories. Drop the blindfold. Execute from memory: for each edge letter, setup → T-perm → undo; run the parity alg once if your edge count was odd; then each corner letter, setup → Y-perm → undo. Open your eyes to a solved cube.

It feels huge the first time — because it is. Start with short memos, don't rush, and lean on everything you already made automatic in Parts 2 and 3.