A Quick and Easy Guide to the 3x3x3 Last Layer

There are many approaches to solving the last layer (LL) of a Rubik’s Cube. This is far from optimal in most regards, except for one: it is very easy to memorize. This approach comprises four steps:

orient LL edge pieces (solve the cross);
orient LL corner pieces (finish OLL)
place LL edge pieces (place edge pieces without disrupting orientation)
place LL corner pieces (finish PLL [and solve the cube!])

Each step requires you to memorize only one algorithm. The algorithms will be defined as they are encountered.

Before You Begin

This guide is specifically for solving the last layer, and assumes you can get as far. If you need help with the first two layers (F2L), look elsewhere first: for example, my recently-resurrected post on solving the F2L, or the top hit on Google.

The algorithms use the standard 3x3x3 algorithm notation used by many other Rubik’s Cube algorithm directories. All images below are from the top-down; i.e., looking at the U face, with the B, R, F, and L faces to the north, east, south, and west, respectively. All argorithms should be applied looking at the F face (not the U face).

Step #1: Edge Orientation

The goal of this step is to go from a scrambled LL to an LL with edges flipped correctly forming a cross; e.g., from something like this:

to (abstractly) something like this:

If you already have a cross, continue to step #2. We do not yet care about the relative positions of edge or corner pieces, and we do not care about the orientation of corner pieces. Considering only the orientation of edge pieces, there are three possible scenarios other than the cross:

Rotate the top layer until you match one of these patterns, and perform the algorithm:

Algorithm #1: F U R U’ R’ F’

In either of the first two cases, you will need to perform the algorithm multiple times (with a rotation before each application). After applying the algorithm no more than three times, you should have a cross.

Step #2: Corner Orientation

The goal of this step is to go from a LL with only edges oriented correctly (forming a cross) to an LL with all edges and corners oriented correctly; e.g., from something like this:

to something like this:

If you already have all edges oriented correctly, continue to step #3. We will not consider the relative placement of any of the corner or edge pieces during this step. Considering only the orientation of the last layer pieces — and, really, just the corner pieces — there are seven possible unsolved scenarios:

Rotate the top layer until you match one of these patterns, and perform the algorithm:

Algorithm #2: R’ U2 R U R’ U R

For most of these states — all but the final — applying the algorithm will simply bring you to another state. Eventually, though, you’ll end up with uniformly oriented last layer.

Step #3: Edge Permutation

The goal of this step is to go from a LL where the edges are placed incorrectly to an LL where the edges are placed correctly, without affecting the orientation of any of the LL pieces.

If you already have all edges placed correctly, continue to step #4. Begin by rotating the LL until at least one edge matches its adjacent center piece. There are only two possible states of unsolved edge pieces:

two edges incorrectly placed
three edges are incorrectly placed

If you followed the directions two sentences ago, there must be at least one correct edge; i.e., not all four edges can be incorrect. Also, it is impossible for only one edge to be incorrect, because an incorrectly placed edge must go somewhere, and whatever other edge is in that somewhere must also be in the wrong location.

If you are in state 2 above, this algorithm (applied once or twice) will fix your edge placement:

Algorithm #3: L’ U L’ U’ L’ U’ L’ U L U L2

If you are in state 1 above, the same algorithm will get you into state 2 above.

Step #4: Corner Permutation

The goal of this step is to go from an LL where only corners are placed incorrectly, to an LL where all pieces are placed correctly, without screwing anything else up — thereby solving the cube.

If you already have all corners placed correctly, your cube should be solved and you should consider going for a walk and getting some fresh air. There are only two possible states of unsolved corner pieces:

three corner pieces are incorrectly placed
four corner pieces are incorrectly placed

You can’t have just one incorrect corner for the same reason you can’t have just one incorrect edge — that corner has got to go somewhere, and whatever corner is in that somewhere must also be in the wrong place. You can’t have just two incorrect corners, because having two incorrect corners is an impossible state if the cube is otherwise solved.

If you are in state 1 above, this algorithm (applied once or twice) will fix your corner placement:

Algorithm #4: R2 B2 R F R’ B2 R F’ R

If you are in state 2 above, this algorithm will get you into state 1 above.

Conclusion

Congratulations: your Rubik’s Cube should now be solved. Or, there’s something wrong with my directions, in which case you should email me and tell me.

Thanks for reading.

Epilogue: Being Less Slow

With some diligence, I think the aforementioned solution method can reasonably get someone below 60-90 seconds when paired with a good F2L method. There are some obvious improvements, though, which will yield good return on investment if you want to get faster.

Recommended Improvement #1: memorize the inverse of Algorithm #1.

Algorithm #1 will directly fix the edge orientation of an “L” pattern, but not a “—” pattern. Behold Algorithm #1b:

Algorithm #1b: F R U R’ U’ F’

This algorithm takes you directly from a “—” pattern to a cross (i.e. with edges oriented correctly) directly, without having to apply Algorithm #1 multiple times.

Recommended Improvement #2: memorize the mirror of Algorithm #3.

Algorithm #3 is useful as a 3-cycle of LL edges, but sometimes you have to apply it twice just because you need to cycle edges counter-clockwise instead of clockwise. Behold algorithm #3b:

Algorithm #3b: R U’ R U R U R U’ R’ U’ R2

If you are at the edge PLL step and encounter any 3-cycle, you will now be able to solve the edge permutation with only one algorithm. (If you don’t encounter a 3-cycle — i.e. you have two pieces out of place — just apply either Algorithm #3 or #3b.)

Recommended Improvement #3: memorize the inverse of Algorithm #4.

For the same reason as improvement #2 above, memorizing the inverse of Algorithm #4 can speed up your corner PLL by reducing the maximum number of 3-cycles you have to do from three to two.

Algorithm #4b: R’ F R’ B2 R F’ R B2 R2

As above, by adding algorithm #4b to your repertoire, you can solve any 3-cycle corner PLL situation by just applying the correct algorithm directly (instead of applying the incorrect one twice). If you don’t have a 3-cycle, just apply either Algorithm #4 or #4b — whichever is faster for your hands.