3D Rubik's Cube Solver

Close ✕

How this solver works — and how to use it for FMC

This tool finds a short solution automatically. For an official WCA Fewest-Moves attempt you solve by hand on paper (no computer), so use this to train, verify ideas, and study short solutions — and use the human method below in the actual event.

The AK-cubie method (this project's original method)

This project began with an original, human-interpretable method — the AK-cubie method. Its idea is to solve the cube one cubie at a time and then combine the small per-cubie solutions into one sequence. It is fully implemented here (tick “Solve with the AK-cubie method”), and it is what the mathematics below was built to support.

Fixed orientation. White centre on the bottom, blue centre facing you. No whole-cube rotation — only the 18 face turns R L U D F B (with ' / 2).

Numbering. Edges UF=0, UR=1, UB=2, UL=3, FR=4, BR=5, BL=6, FL=7, DF=8, DR=9, DB=10, DL=11; corners UFR=0, UBR=1, UBL=2, UFL=3, DFR=4, DBR=5, DBL=6, DFL=7. A state is four arrays: edge positions, edge orientations, corner positions, corner orientations.

Orientation labels (the AK convention).
• Edges: 0 = good (solvable with R,L,U,D only), 1 = bad (needs F/B).
• Corners, by where the white/yellow sticker points: 0 = good (up/down), 1 = side (left/right), 2 = face (front/back).

Per-cubie move tables. For every single cubie state a solution of at most 3 moves is precomputed — 276 edge states and 184 corner states — generated and verified in docs/edge-move-tables.txt and docs/corner-move-tables.txt.

Combining cubies. To place the next cubie without disturbing the solved ones, take its ≤3-move solution and insert “don't-care” moves (moves that don't affect placed pieces), then keep the shortest compatible merges. Growing the solved region this way — pairs → 2×2 squares → larger blocks — is the heart of the method.

Beam (branch trimming). At each step the search keeps only the N shortest partial sequences and discards the rest — a tree that is pruned to bound memory. N is set by the Beam box (default 50); higher N explores more branches (fewer moves, more memory), lower N is faster and lighter. If the branch list ever grows past a safety limit the search halts rather than exhausting memory.

Relationship to Petrus. The AK-cubie method fits directly into the well-known Petrus method — both grow a solved block cubie by cubie:
• Petrus 2×2×2 and 2×2×3 = AK-cubie combining (add cubies/pairs with don't-care merging).
• Petrus edge orientation (EO) = the AK-cubie good/bad edge label exactly.
• Petrus F2L completion = more block-adding.
So the AK-cubie engine can serve as the block-building + EO stages of a Petrus solve; only the last layer differs, where Petrus uses memorized last-layer algorithms.

Honest note on move count. The AK-cubie method is readable and faithful to the original idea. It is a fully human-readable, part-by-part solve, always in the same structure: (1) build a 2×2×2 block, (2) extend it to a 2×2×3, (3) complete the first two layers (F2L) by adding corner + edge pairs, then (4) solve the whole last layer in a single sequence (1LLL). Each block is solved as an optimized group (e.g. the 2×2×2 in ~6–7 moves) rather than one cubie at a time, and the app tries all 24 starting orientations and keeps the fewest-move result (typically ~30–36 moves). The “thinking process” panel shows each part with the block colours it builds.

No move-count tricks. The AK-cubie method deliberately does not use NISS or insertions, and it never mixes the last layer into the F2L — so every part of the printed solution can be explained and followed on its own. This keeps it honest and teachable, at the cost of a few moves. For the outright fewest-move goal the pure two-phase engine (below) wins (~18–20 moves), so it is what the Solve button reports by default. Tick “Use the AK-cubie method” to run and view your block-building + 1LLL solution.

1. The cube as mathematics

A cube state is a permutation with orientation. There are 8 corners and 12 edges:
• corner permutation ∈ S₈, corner orientation ∈ (ℤ₃)⁸ with the constraint that the twists sum to 0 (mod 3) — so 3⁷ possibilities;
• edge permutation ∈ S₁₂, edge orientation ∈ (ℤ₂)¹² with an even-parity constraint — so 2¹¹ possibilities;
• corner and edge permutation parities must match.
Total reachable states = 8! · 3⁷ · 12! · 2¹¹ / 2 ≈ 4.3 × 10¹⁹. Every state is solvable in ≤ 20 moves (“God’s Number”, HTM).

This project uses a geometric orientation label (which axis the white/yellow sticker points along); internally it is converted to the standard twist coordinate with a fixed per-position map, verified to satisfy the sum-mod-3 invariant.

2. Two-phase (Kociemba) search — the engine

Solving optimally is expensive, so we solve in two phases through an intermediate subgroup
G1 = ⟨U, D, R2, L2, F2, B2⟩.
Phase 1 reduces the cube into G1: orient all edges (EO=0), orient all corners (CO=0), and move the four middle-slice edges into the middle slice. Coordinates: edge-orientation (2¹¹), corner-orientation (3⁷), slice-position (C(12,4)=495).
Phase 2 solves the cube while staying in G1, using only ⟨U,D,R2,L2,F2,B2⟩. Coordinates: corner permutation (8!), U/D-edge permutation (8!), slice permutation (4!).

Each phase is an IDA* search guided by pattern-database pruning tables (built by breadth-first search from the goal). The heuristic is the max of two table lookups, which is an admissible lower bound, so the search is efficient and correct. Typical result: ~18–20 moves.

3. Squeezing fewer moves

• 24 orientations. The same scramble solved from each whole-cube rotation gives different-length solutions (the phase-1 axis choice matters). We try all 24 and keep the best.
• NISS (inverse scramble). If S solves the inverse of a scramble, then the reverse-and-invert of S solves the original — often a move or two shorter.
• Insertions. Find a short skeleton that leaves a single 3-cycle, then insert a commutator that fixes it at the spot where its moves cancel with the skeleton.
• Time budget. Longer search = more candidates tried = fewer moves. The bar shows progress.

4. A step-by-step method you can follow (block-building)

This is a full walkthrough of the Petrus-style block-building method. Move counts in parentheses are typical. You never need long algorithms until the last layer, and after the EO step you finish almost everything with just R and U.

Before you start. Pick any one corner piece to be the “seed” of your block — say the white-blue-orange corner. Everything you build grows outward from there. Centers never move relative to each other, so a center tells you a face’s colour.

Step 1 — Build a 2×2×2 block (≈ 5–7 moves). Assemble the seed corner plus the three edges and three centers that touch it, into one solid 2×2×2 corner.

• 1a. Make a pair: join the seed corner with one of its edges — line them up on the same face and turn once so they stick together (a “1×1×2”).
• 1b. Make an “L”: add a second edge next to that pair. Move the pair out of the way, bring the second edge into place, then restore — usually 2–3 turns.
• 1c. Close the block: insert the third edge to complete the 2×2×2. Look for pieces already near their spot to save moves.

Step 2 — Extend to a 2×2×3 block (≈ 5–8 moves). Grow your 2×2×2 into a 2×2×3 by adding the two edges and one corner directly beside it. Hold the finished 2×2×2 in the bottom-left-back; build the 2×2×3 upward/forward from it. Keep the 2×2×2 intact — use turns of the two faces that don’t touch it, and always “restore” the block if you disturb it (turn away, insert a piece, turn back).

Step 3 — Orient the remaining 6 edges, “EO” (≈ 1–4 moves). This is the key insight. Position the 2×2×3 block on the left (it fills the left two layers). Only the right side is unsolved. A right-side edge is “good” if you can finish it later with only R/U turns, and “bad” if it would need an F or B turn to flip it.

• 3a. Spot bad edges: look at the 6 unsolved edges. An edge is bad if its top/bottom (white/yellow) colour is facing F or B; for the edges that have no white/yellow, it’s bad if its front/back colour faces U or D.
• 3b. Fix them: a single F or B turn flips 4 edges at once. Choose F/B turns (sometimes with a U in between to line up which 4 get flipped) so that afterwards all 6 edges are good. This is almost always 1–3 moves.
• Payoff: once EO is done, no more F or B turns — you finish with R and U only.

Step 4 — Finish the first two layers, “F2L” (≈ 6–12 moves). Complete the bottom two layers using only R and U. You are inserting the last corner+edge pairs into the empty right slot:

• 4a. Bring a corner+edge pair to the top with U, lined up above their slot.
• 4b. Insert with a short R U R'-style trigger. Repeat for each remaining pair.
• Now the whole cube is solved except the top (last) layer.

Step 5 — Last layer (≈ 8–14 moves). Solve the top in two looks (easier) or one look (fewer moves):

• 5a. Orient the last layer so the whole top face is one colour. For corners use a Sune (R U R' U R U2 R'); repeat with a U adjustment for other cases. Flip any remaining top edges with a short edge-orient alg (F R U R' U' F').
• 5b. Permute the top pieces into place with 3-cycle algorithms (see the table below): one for corners, one for edges. Add a final U (“AUF”) to align.
• 1-look (1LLL): advanced solvers memorise one algorithm that does 5a + 5b together — fewer moves, but ~4000 cases.

Useful, verified algorithms (HTM):

Purpose	Algorithm
Trigger (“sexy move”)	R U R' U'
Orient top corners (Sune)	R U R' U R U2 R'
Orient top edges (line → cross)	F R U R' U' F'
Corner 3-cycle	R U R' D R U' R' D' = [R U R', D]
Corner 3-cycle (mirror)	R' D' R U R' D R U'
Edge 3-cycle (Ua perm)	R2 U R U R' U' R' U' R' U R'
Edge 3-cycle (Ub perm)	R U' R U R U R U' R' U' R2

5. Cutting moves for FMC (NISS + insertions), step by step

FMC rewards effort, not speed: you have ~1 hour and paper. Find several solutions with the method above (from different starting corners / angles) and keep the shortest. Then squeeze it:

NISS — “Normal-Inverse Scramble Switch”, step by step:

1. Write the scramble and, underneath, its inverse (reverse the order and invert every move: R↔R', R2 stays R2).
2. Start solving on the normal scramble; write those moves as list A.
3. If the normal side gets awkward, switch: apply the moves you have to the inverse scramble and keep solving there; write those moves as list B.
4. Recombine: the final solution is (A), then (B reversed, with each move inverted). Example: normal A = R U, inverse B = F L' → reverse B to L' F, invert each to L F', so the solution = R U L F'.
5. Switching lets you find an easy 2×2×2 on whichever side is friendlier — often saving several moves.

Insertions — fix a 3-cycle inside a skeleton, step by step:

1. Solve until only a single 3-cycle of 3 corners (or 3 edges) is left — call the rest your skeleton (e.g. 18 moves).
2. Pick the commutator that performs that 3-cycle (e.g. R U R' D R U' R' D').
3. Try placing it at every gap between skeleton moves. At each gap, adjust (“conjugate”) the commutator so it targets the right pieces there.
4. Count cancellations: if the skeleton has … R right before an insertion that starts with R', they cancel (net 0); R then R becomes R2; R then R2 becomes R'. Keep the gap that cancels the most.
5. Example of cancellation: skeleton … F R + insertion R' U R U' … → the R R' vanish, saving 2 moves. A good insertion of an 8-move commutator can net as few as 4–5 moves.
6. Advanced: try 2 insertions and let them cancel with each other, too.

Commutators & conjugates (why they’re perfect for insertions): a commutator [A, B] = A B A' B' disturbs only a few pieces — ideal to slot in. A conjugate [A : B] = A B A' means “set up with A, do B, undo the setup”; the setup moves are what cancel against your skeleton.

6. Notation

U D R L F B = turn that face 90° clockwise (viewed from outside); ' = counter-clockwise; 2 = 180°. HTM = Half-Turn Metric (each of these counts as one move). This app displays and animates solutions in the white-up / green-front view frame.

7. Ergonomic execution (one-hand / two-hand)

Under each solution the app shows two re-notated versions that are more comfortable to turn. They perform the same solve — every move is expanded back to face turns and checked against the original, so they can only differ in comfort, never in result. (They may finish in a rotated but fully solved orientation.)

Use the Execute as selector (Normal / One-hand / Two-hand) to choose which version the Play and Step buttons animate. Picking one resets the cube to the original scramble so you can watch or follow that sequence from the start; the chosen sequence is highlighted as it plays.

• One-hand (OH). Keeps turns on the easy R and U faces using whole-cube rotations x y z and wide (two-layer) moves r u …. Lowercase = turn two layers together.
• Two-hand (2H). Mostly plain face turns (all six are two-hand friendly), avoiding the awkward B face; introduces wide moves and, where the solution allows, slice moves M E S (turn the middle layer: M like L, E like D, S like F).

Move identities used (all verified against an independent geometric cube model): r = x L, l = x' R, u = y D, d = y' U, f = z B, b = z' F; M = x' R L', E = y' U D', S = z F' B.

Honest note. This is an automatic ergonomic rendering (rotations, wides and slices are inserted by a shortest-cost orientation search), not a hand-tuned fingertrick solution. A human speedsolver may still regrip differently. Slice moves appear only where the solution's structure supports them without adding moves — forcing them elsewhere would make execution worse, not better.