21 PLL Algorithms (Full List + Easy Rubik's Cube Guide)

Solving a Rubik's Cube is like climbing a mountain — it takes patience, precision, and a solid strategy. Once you're familiar with the CFOP method (Cross, F2L, OLL, and PLL), the final and most satisfying step is the Permutation of the Last Layer, better known as PLL algorithms.

PLL algorithms are where magic happens. After orienting the last layer with OLL, PLL is used to move the remaining pieces into their correct positions, completing the cube. It's the cherry on top of your solving process and the key to becoming a faster speedcuber.

Let's break down what is PLL in Rubik's Cube solving, explore the various 3x3 PLL algorithms involved, and tackle some common questions to help you get that final edge.

What Is PLL in Rubik's Cube Solving?

PLL, or Permutation of the Last Layer, is the final stage in the CFOP method. After you complete the first two layers (F2L) and orient all the last-layer stickers using OLL, PLL comes into play to solve the last layer completely.

The goal of Rubik's Cube PLL algorithms is simple: to permute (or move) the last-layer corners and edges into their correct spots without disturbing their orientation. There are 21 standard PLL algorithms, and each has its own specific pattern and move set.

At this stage, the cube looks almost solved — the last-layer color is complete, but pieces are scrambled. 3x3 PLL algorithms are used to fix that in a single, efficient step.

The Two Types of PLL Moves

There are two main types of permutations in PLL algorithms: corner permutations (4 cases) and edge permutations (17 cases).

Corner Permutations

Corner permutations include Aa, Ab, and E. These involve only corners, while others like F perm affect both corners and edges. These cases are usually shorter and easier to memorize, and now let's break them down one by one.

Name	Case	Algorithm	Group
Aa		x L2 D2 L' U' L D2 L' U L'	Adjacent Corner Swap
Ab		x' L2 D2 L U L' D2 L U' L	Adjacent Corner Swap
E		x' L' U L D' L' U' L D L' U' L D' L' U L D	Diagonal Corner Swap
F		R' U' F' R U R' U' R' F R2 U' R' U' R U R' U R	Adjacent Corner Swap

Annotation:

• Aa: This is the name or label of a specific PLL case or algorithm. PLL cases are typically named with letters or letter pairs (like Aa, Ab, T, Y, etc.) to identify different permutations of the last layer pieces.
• x R' U R' D2 R U' R' D2 R2 x': This is a sequence of cube moves (an algorithm) used to solve the PLL case named "Aa". The letters and symbols represent specific face turns and cube rotations:
  1. R, U, D, L, F, B: These are the standard notations for turning the Right, Up, Down, Left, Front, and Back faces of the cube clockwise 90 degrees:
  2. x and x': These are cube rotations around the x-axis (rotating the entire cube as if turning the right face forward). x is clockwise rotation, x' is counterclockwise.
  3. A letter followed by a prime (') means a 90-degree counterclockwise turn of that face (e.g., R' means turn the right face counterclockwise).
  4. A number 2 after a letter means a 180-degree turn (e.g., D2 means turn the down face 180 degrees).

So the sequence "x R' U R' D2 R U' R' D2 R2 x'" means: rotate the cube on the x-axis clockwise, then perform the moves R' U R' D2 R U' R' D2 R2, then rotate the cube back on the x-axis counterclockwise.

Edge Permutations

These algorithms affect only the edge pieces. Some notable edge cases include: Ga, Gb, Gc, Ua, Ub, Z, H, T, J, R, G, N, etc, and check them one by one.

Name	Case	Algorithm	Group
Ga		R2 U R' U R' U' R U' R2 U' D R' U R D'	Corner-edge Swap
Gb		R' U' R U D' R2 U R' U R U' R U' R2 D	Corner-edge Swap
Gc		R2 U' R U' R U R' U R2 U D' R U' R' D	Corner-edge Swap
Gd		R U R' U' D R2 U' R U' R' U R' U R2 D'	Corner-edge Swap
H		M2 U M2 U2 M2 U M2	Edges Only
Ja		x R2 F R F' R U2 r' U r U2	Adjacent Corner Swap
Jb		R U R' F' R U R' U' R' F R2 U' R'	Adjacent Corner Swap
Na		R U R' U R U R' F' R U R' U' R' F R2 U' R' U2 R U' R'	Diagonal Corner Swap
Nb		R' U R U' R' F' U' F R U R' F R' F' R U' R	Diagonal Corner Swap
Ra		R U' R' U' R U R D R' U' R D' R' U2 R'	Adjacent Corner Swap
Rb		R2 F R U R U' R' F' R U2 R' U2 R	Adjacent Corner Swap
T		R U R' U' R' F R2 U' R' U' R U R' F'	Adjacent Corner Swap
Ua		M2 U M U2 M' U M2	Edges Only
Ub		M2 U' M U2 M' U' M2	Edges Only
V		R' U R' U' y R' F' R2 U' R' U R' F R F	Diagonal Corner Swap
Y		F R U' R' U' R U R' F' R U R' U' R' F R F'	Diagonal Corner Swap
Z		M' U M2 U M2 U M' U2 M2	Edges Only

These Rubik's Cube PLL algorithms can look intimidating, but with the right finger tricks, they become second nature.

Tips for Learning All PLL Algorithms

Mastering all PLL algorithms may feel overwhelming at first, but with the right approach, it's completely achievable. Here's how to make your learning efficient, enjoyable, and long-lasting.

Start With 2 Look PLL Algorithms

If you're just transitioning from beginner to intermediate solving, 2 look PLL algorithms are your best friend. This method breaks the PLL step into two smaller parts: first, solving the corners, then the edges.

You'll only need to learn about 6–7 algorithms to cover the most common situations. This keeps things simple and allows you to focus on recognition and clean execution, without getting overwhelmed by the full set of 21.

Once you're consistently getting sub-30 times, you'll be ready to level up.

Learn in Small, Manageable Sets

Instead of tackling all 21 3x3 PLL algorithms at once, break them down into smaller chunks. Learn 2 or 3 algorithms per week, and focus on mastering one type of case at a time (like corner perms first, then edge perms).

Start with common and easier algorithms, such as:

• Ua/Ub (edge 3-cycles)
• T perm (a common and smooth edge-corner swap)
• J perms (great for speed training)

Build confidence with these before moving to trickier cases like the G perms and E perm.

Use Muscle Memory and Finger Tricks

Speedcubing is all about fluidity. Don't just memorize algorithms visually — train your hands to execute them automatically.

Repeat each PLL algorithm 10–20 times per session. Focus on finger tricks — these are efficient, minimal-movement techniques used by top cubers to turn quickly and smoothly. Over time, this builds speed and consistency.

Apps like CubeSkills and YouTube tutorials can demonstrate the best finger tricks for each case.

Focus on Recognition Training

Knowing the algorithm isn't enough — you need to recognize PLL cases instantly during solves.

Practice identifying corner and edge positions: look for headlights (two matching corner stickers), bar patterns, and color placements. One great method is flashcard-style drills. Use images of different PLL cases and time yourself on recognition alone — then run the correct algorithm afterward.

Doing this regularly will improve your speed and reduce hesitation during timed solves.

Group Similar and Mirror Cases

Many PLL algorithms have mirrored versions. For example:

• Ua and Ub
• Ja and Jb
• Ra and Rb

These are visually and structurally similar, with just mirrored moves. Learn them together to speed up the memorization process and deepen your pattern recognition. You'll also spot them quicker in real solves if you know how the mirrored pairs work together.

Drill PLL in Isolation

Take time to practice just the PLL stage during your sessions. Use a cube timer or scrambler that places you directly into a PLL case, so you can focus solely on fast execution. Web tools and apps like cstimer, CubeSkills, and Jperm.net offer scramble generators specifically for PLL training. Isolating PLL in your practice helps sharpen speed and build confidence under pressure.

Use the Cube Solver AI App for Smart Assistance

When you need guidance or want to practice on the go, check out the Rubik's Cube Solver App.

It offers dynamic, step-by-step guides for solving 3x3, as well as support for 2x2 and 4x4 cubes. Just scan your cube and follow the on-screen animations — perfect for learning, troubleshooting, or double-checking your PLL cases.

Whether you're stuck or want to study specific Rubik's Cube PLL algorithms, this app gives you real-time help that fits right in your pocket.

Why Full PLL Algorithms Matter for Speedcubing

As you improve your solve time, PLL algorithms become more important. Being able to instantly recognize and execute 3x3 PLL algorithms can shave precious seconds off your time.

Many cubers credit their leap to sub-20 or sub-15 averages to finally learning all PLL algorithms. The smoother your execution, the closer you get to a competition-ready performance.

By mastering Rubik's Cube PLL algorithms, you reduce hesitation, improve transitions from OLL, and finish strong every time.

Conclusion

Whether you're learning 2 look PLL algorithms or grinding out full PLL algorithms, this step is crucial for pushing your skills forward. Don't be overwhelmed by the number of cases — take it one algorithm at a time. Remember, PLL algorithms are the final push toward solving a cube like a pro. With consistent practice, recognition drills, and clean execution, you'll soon have all Rubik's Cube PLL algorithms in your arsenal.

Stick with it — the finish line is just one algorithm away.

PLL Algorithms FAQ

Q: What are the easiest PLL algorithms?

Some of the easiest PLL algorithms to learn and execute include:

• Ua and Ub: simple 3-edge cycles with clean move sets
• T perm: a fast and intuitive corner-edge swap
• J perms: quick and widely used in speedsolving

These are smooth to execute and appear often, making them ideal for beginners to start with.

Q: What is the hardest PLL algorithm?

Many cubers find the E perm and G perms challenging. These PLL algorithms involve awkward hand positioning and longer move sets, but they become easier with repetition.

Q: Is it better to learn OLL or PLL first?

It's generally recommended to learn PLL first. There are only 21 PLL algorithms compared to 57 in full OLL. Starting with 2 look PLL algorithms helps you build confidence before tackling the more complex OLL step. Once you're comfortable with PLL, you can move on to learning 2 look OLL, then eventually full OLL.

Q: Do I need to learn all PLL algorithms right away?

No. Start with 2 look PLL algorithms — just 6–7 are enough for sub-30 solves. As you get faster, gradually add more until you know the full PLL algorithms set.

Q: How many PLL algorithms are there?

There is no fixed number of PLL (Phase-Locked Loop) algorithms, because different applications use different implementations. However, the most commonly recognized PLL algorithms include:

• Analog PLL (APLL): Traditional hardware-based phase-locked loop.
• Digital PLL (DPLL): PLL implemented using digital signal processing.
• Costas Loop: A PLL variant used for carrier recovery in communication systems.
• Software PLL (SPLL): PLL implemented in software, often used in embedded or DSP systems.
• Higher-order PLL algorithms: Such as second-order and third-order PLLs, designed for improved stability and tracking.