List Of Algorithms For Rubik's Cube

Solving a Rubik’s Cube is rarely about memorizing a single sequence; it is about building a toolkit of specific move sets—known in the cubing community as algorithms (or algs)—that manipulate specific pieces without disturbing the rest of the solved puzzle. Whether you are a beginner learning the Layer-by-Layer method or an advanced solver optimizing for sub-10 times using CFOP, Roux, or ZZ, your progress hinges on the algorithms you know and how efficiently you execute them.

This guide breaks down the essential algorithms categorized by solving method and stage, providing the standard notation and context for when to use each one Easy to understand, harder to ignore..

Understanding Notation and Finger Tricks

Before diving into the lists, fluency in Singmaster Notation is non-negotiable. Practically speaking, a letter alone means a 90-degree clockwise turn. An apostrophe (') denotes a 90-degree counter-clockwise turn. In real terms, the standard faces are R (Right), L (Left), U (Up), D (Down), F (Front), B (Back). A 2 indicates a 180-degree turn Worth knowing..

Wide turns (lowercase letters: r, u, f, etc.) move two layers simultaneously and are critical for 4x4+ cubes and advanced 3x3 techniques. Slice moves (M, E, S) move the middle layers. Mastering finger tricks—executing turns with specific fingers rather than whole wrists—is what transforms a memorized sequence into a sub-2-second execution Most people skip this — try not to..

1. Beginner Method (Layer-by-Layer) Essentials

This method requires the fewest algorithms, making it the entry point for almost everyone. You only need roughly 5–7 core sequences.

The Daisy & White Cross

No algorithms required. This is intuitive. Focus on aligning the white edge pieces with the white center, then matching the side colors to their respective centers before bringing them down to the bottom.

First Layer Corners (The "Sexy Move")

This single sequence solves the first layer corners. It is the foundation of commutators.

• Algorithm: R U R' U'
• Usage: Repeat until the corner is oriented and permuted correctly in the bottom layer.
• Mirror (Left hand): L' U' L U

Second Layer Edges

Two algorithms (mirrors of each other) insert edges from the top layer into the middle layer Not complicated — just consistent..

• Insert Left: U' L' U L U F U' F'
• Insert Right: U R U' R' U' F' U F

Yellow Cross (OLL - Orientation of Last Layer)

You will encounter three patterns on the yellow face: Dot, L-shape, Line. One algorithm cycles through them.

• Algorithm: F R U R' U' F'
• Cycle: Dot → L-shape (hold in top-left) → Line (hold horizontally) → Cross.

Align Yellow Cross Edges

Swap the front and left edges (or front/back) to match center colors The details matter here..

• Algorithm (Sune): R U R' U R U2 R' U
• Variation (Anti-Sune): R U2 R' U' R U' R' (Swaps front/back edges).

Position Yellow Corners

Cycle three corners (keep the solved one in Front-Right).

• Algorithm: U R U' L' U R' U' L

Orient Yellow Corners (Final Step)

The infamous "Down, Away, Up, Back" sequence Worth knowing..

• Algorithm: R' D' R D
• Process: Hold the cube so the unsolved corner is Front-Right-Up. Repeat R' D' R D either 2 or 4 times until yellow faces up. Rotate only the U layer (U or U') to bring the next bad corner to Front-Right-Up. Do not rotate the whole cube.

2. CFOP Method: The Speedcubing Standard

CFOP (Cross, F2L, OLL, PLL) is the dominant method for world-class solvers. The algorithm count jumps significantly here: ~78 algorithms for full 2-Look/Full OLL and PLL, plus hundreds of intuitive F2L cases.

F2L (First Two Layers) — Mostly Intuitive

Full CFOP treats F2L as intuitive block building. On the flip side, specific "stuck" cases have algorithmic solutions for efficiency.

• Standard Insert (Corner+Edge paired): R U R' or F' U' F
• Case: Corner Top, Edge Top (Separated):
  • Hide edge, insert corner: R U' R' U R U R'
  • Use empty slot: R U R' U' R U R'
• Case: White Sticker on Top (Corner): R U2 R' U' R U R' (or R U R' U2 variations).

2-Look OLL (Orientation of Last Layer) — 10 Algorithms

This reduces the 57 full OLL cases to two steps: Edges first, then Corners Easy to understand, harder to ignore..

Step 1: Orient Edges (3 Algs)

1. Dot: F R U R' U' F' f R U R' U' f' (or F R U R' U' F' U2 F U R U' R' F')
2. L-Shape (Back-Left): f R U R' U' f' (Wide moves)
3. Line (Horizontal): F R U R' U' F'

Step 2: Orient Corners (7 Algs — "The 7 OLLs")

1. Sune: R U R' U R U2 R'
2. Anti-Sune: R U2 R' U' R U' R'
3. H / Cross: R U R' U R U' R' U R U2 R' (or F R U R' U' R U R' U' R U R' U' F')
4. Pi / Air Jeff: R U2 R2 U' R2 U' R2 U2 R
5. U / Headlights: R2 D R' U2 R D' R' U2 R' (or R U R' U R U' R' U R U2 R' — different finger tricks)
6. T / Chameleon: r U R' U' r' F R F'
7. L / Bowtie: F R' F' r U R U' r'

Full OLL — 57 Algorithms

Learning Full OLL allows you to orient all last-layer pieces in a single look. They are categorized by shape:

• Cross Shapes (6 cases): Fast, flowy algs (e.g., R U R' U' R' F R2 U' R' U' R U R' F').
• P Shapes (4 cases): Mirror pairs.
• W Shapes (4 cases): Awkward finger tricks, often use R U R' U triggers.
• Awkward Shapes (T, U, L, H, Pi): The remaining non-cross cases.
• Key Strategy: Learn in groups sharing similar triggers (e.g., all R U R' U' based algs) to build muscle memory transfer.

2-Look PLL (Permutation of Last Layer) — 6 Algorithms

Permutes pieces after orientation.

Step 1: Permute Corners (2 Algs)

1. Headlights (Adjacent Swap): R' F R' B2 R F' R' B2 R2 (A-Perm)
   Hold headlights in Back.
2. No Headlights (Diagonal Swap): F R U' R' U' R U R' F' R U R' U' R' F R F' (E-Perm / Y-Perm variation)
   Or standard Y-Perm: F R U' R' U' R U R' F' R U R' U' R' F R F'

Step 2: Permute Edges (4 Algs)

1. 3-Cycle CW (Ua): R U' R U R U R U' R' U' R2
2. 3-Cycle CCW (Ub): R2 U R U R' U' R' U' R' U R'
3. Opposite Swap (H): M2 U M2 U2 M2 U M2
4. Adjacent Swap (Z): M2 U M2 U M' U2 M2 U2 M' U2

Full PLL — 21 Algorithms

Mastering Full PLL eliminates the "2-Look" pause, allowing instant recognition and execution of the final layer permutation Practical, not theoretical..

• G-Perms (4 cases): The most frequent PLLs (~40% probability). All share the R2 u R' U R' / R' U' R u' R2 trigger structure. Critical to learn RUD vs RUF variations for angle neutrality.
• A-Perms (2 cases): Fast R' F R' B2 triggers. Mirror images.
• T / J / R / V / Y / F / N / E / Z / H: The remaining "standard" set.
• Recognition System: Use 2-Look Recognition (Headlights/Blocks) for corners + Edge Cycle direction for edges. Advanced solvers use Block Recognition (identifying 2x1x1 blocks) for sub-1.5s inspection-to-execution transition.

3. Roux Method: The Efficiency Specialist

Roux (First Two Blocks → CMLL → LSE) prioritizes low move count (~45–48 STM) and ergonomic M/U turns over algorithm count (~42 algorithms for CMLL + intuitive blocks).

First Two Blocks (FB + SB) — Fully Intuitive

1. First Block (FB): Build a 1x2x3 block on Left (DL + FL + UL + DFL + UFL). Plan entirely in inspection.
2. Second Block (SB): Build 1x2x3 on Right (DR + FR + UR + DFR + UFR) using only R, r, M, U moves. Preserves FB.

CMLL (Corners of Last Layer) — 42 Algorithms

Orients and permutes U-layer corners simultaneously while ignoring M-slice edges.

• Subsets: Sune, Anti-Sune, H, Pi, U, T, L (same names as OLL, but different algs optimized for R/U/M).
• Key Advantage: No AUF (Adjust U Face) needed before execution; recognition is purely corner sticker patterns.

LSE (Last Six Edges) — Intuitive / Semi-Algorithmic

Solved in 3 sub-steps using only M and U moves:

1. EO (Orientation): Orient UL/UR edges (M' U M, M' U2 M, etc.).
2. UL/UR Placement: Insert the two oriented edges into the Left/Right slots (U M' U2 M, U' M U2 M').
3. EP (Permutation): Solve final 4 M-slice edges (U M2 U' M2, M2 U M2 U2 M2, etc.).

4. ZZ Method: The Ergonomic Innovator

ZZ (EOLine → F2L → LL) front-loads difficulty: EOLine (orient all edges + place DF/DB) enables rotationless, R/U/L-only F2L.

EOLine — Inspection Heavy

• Orient all 12 edges (good/bad relative to F/B centers).
• Place DF and DB edges.
• Move Count: ~6–9 moves. Requires high inspection proficiency

EOLine — Inspection Heavy

• Orient all 12 edges (good/bad relative to F/B centers).
• Place DF and DB edges.
• Move Count: ~6–9 moves. Requires high inspection proficiency; top solvers plan the entire line + first F2L pair during the 15-second inspection window.
• EOArrow / EOCross: Common variants. EOArrow places DF + two adjacent D-layer edges (easier planning, slightly worse ergonomics). EOCross solves the full D-layer cross (heaviest inspection, best F2L flow).

F2L — Rotationless & Ergonomic

With edges pre-oriented, F2L pairs are solved using only <R, U, L> moves (and D for slot positioning). Zero cube rotations (x, y, z) eliminates regripping time and wrist strain Took long enough..

• Blockbuilding Freedom: Unlike CFOP’s rigid "pair-and-insert," ZZ F2L allows Heise-style blockbuilding, keyhole techniques, and multi-pairing.
• Influence on LL: The final F2L pair can be manipulated to force EO-preserving OLL skip (Winter Variation / VLS) or easier PLL cases.

Last Layer Variants

1. OCLL + PLL (2-Look): 7 OCLL algs (subset of OLL) + 21 PLL. Standard entry point.
2. COLL + EPLL: 42 COLL algs orient/permute corners + solve edge orientation; finishes with 4 EPLL algs. High alg count, but enables 1-look LL frequently.
3. ZBLL (Zborowski-Bruchem Last Layer): 493 algorithms. Solves LL in 1 look from any F2L state with oriented edges. The theoretical ceiling for ZZ; sub-10 movecount average.
4. NMLL / CT / TTLL: Modern "middle-ground" subsets (50–100 algs) targeting specific LL states (e.g., corners permuted, edges oriented) for high ROI.

5. Petrus Method: The Blockbuilding Classic

Petrus (2x2x2 → 2x2x3 → EO → F2L → LL) pioneered move efficiency and blockbuilding decades before Roux/ZZ popularized them. Move count: ~50–55 STM That's the part that actually makes a difference..

Steps

1. 2x2x2 Block: Build anywhere (usually DBR). 3–5 moves planned in inspection.
2. Expand to 2x2x3: Extend block using only 2 faces (e.g., R, U if block is DBR). No rotations.
3. EO (Edge Orientation): Orient remaining 7 edges using R, U, F triggers (F R U R' U' F', R U R' U R U2 R', etc.). Critical: This restricts final F2L to <R, U> gen.
4. Finish F2L: Solve remaining two slots <R, U>-gen. Extremely fast, rotationless, highly ergonomic.
5. Last Layer: Standard OLL/PLL (edges pre-oriented → 7 OCLL cases) or COLL/EPLL.

Why It Faded (And Why It Matters)

Petrus lacks the algorithmic structure of CFOP and the dedicated M-slice efficiency of Roux. On the flip side, Step 3 (EO) is the direct ancestor of ZZ’s EOLine, and its blockbuilding philosophy underpins modern FreeFOP (CFOP with blockbuilding F2L) and Hexagonal Francisco Small thing, real impact..

6. Emerging & Hybrid Methods

The competitive landscape evolves via hybridization, stealing the strongest mechanic from each system.

TSM (Tucker's Simple Method) | EO → DR → F2L → LL | Beginners transitioning to advanced methods; combines ZZ's efficiency with CFOP's familiarity. | | Hexagonal Francisco | Hexagon (2x2x3 block) → EO → F2L → LL | Solvers preferring intuitive blockbuilding over algorithmic F2L. | | Y-Roux | Roux with Y-axis rotation for better ergonomics | Advanced Roux users seeking improved lookahead and finger tricks. |

These hybrids reflect a broader trend: method efficiency is no longer binary—solvers cherry-pick elements like EOLines, blockbuilding, and algorithmic LL systems to craft personalized approaches. The "best" method increasingly depends on solver preference, ergonomic comfort, and recognition speed rather than raw move count alone.

Conclusion: Efficiency Is Personal

Speedcubing methods have evolved from rigid step-by-step sequences into modular toolkits. While CFOP remains dominant due to its balance of speed and learnability, Roux and ZZ offer compelling alternatives for those prioritizing move efficiency or ergonomic solving. Meanwhile, Petrus and newer hybrids demonstrate that innovation often lies not in reinventing the cube, but in recombining proven ideas Worth keeping that in mind..

The future belongs to flexible frameworks—methods that adapt to the solver rather than forcing conformity. Whether you're optimizing for sub-10 movecount, 1-look LL, or simply buttery finger tricks, there's now a method (or a mix) made for your style. In speedcubing, as in life, efficiency isn’t one-size-fits-all—it’s about finding the system that fits you The details matter here..