Speedcubing

/ˈspiːdkjuːbɪŋ/
-noun
1. The art and sport of solving a Rubik's Cube in least time possible.

Welcome to the obsession. My current speedcubing method for Rubik's Cube is the Fridrich
method with the following extra techniques:

 Extended cross and other block approaches to F2L when possible.

 F2L cross on bottom or left. Frequent use of empty slots and miscellaneous tricks.
 Multiple algorithms for corner-edge pairs to minimize pause and regripping.
 Avoiding 4 wrong LL edges when fixing the fourth slot (but only when it flows nicely from
the rest of the F2L)
 The nicer patterns from COLL when all LL edges are correctly oriented
 PLL recognition by blocks of continuous colors

With this method I set multiple world records between 2004 and 2006 in both single solve and
average of 5 for 3x3x3 speedcubing.

Menu
How should I learn the Fridrich Method?
Fridrich and Beyond
Other Speedcubing Methods
Memorizing Algorithms

How should I learn the Fridrich Method?

You just bought a Rubik's Cube and can't wait to start learning the Fridrich Method? Not so fast.
The Fridrich Method is quiteadvanced and is meant for cubers near 30 seconds who want to
average under 20. Since the full Fridrich method requires a large number of algorithms, it is best
to learn it in several steps.

Step 0: Preliminaries
Before anything, you should select a color scheme and learn the notation.

Step 1: Simple Layer-by-Layer

Learn Leyan's Beginner Solution. The Fridrich Method is based on the Layer-by-Layer (LBL)
approach, which solves the three layers of the cube in order: first, middle, then last.
Although full Fridrich actually combines the first two layers, the simple LBL method in
Leyan's guide will get you started in the right direction.

Make sure to keep the cross on either bottom or left during the first two layers. Since this
method requires about 110 moves, only 2 turns per second is needed to get a sub-minute
average.

I realize that Jasmine's beginner page is the standard among layer-by-layer beginner's

method guides. I recommend Leyan's over Jasmine's because Leyan teaches to do the first
two layers with the cross on bottom. Later on, this will make looking ahead much easier and
will be crucial for those sub-20 times.

"Algorithms" needed: 11 total. Of these, only 4 are for the last layer. The rest are short
and mostly intuitive "algorithms."
Moves on Average: ~110 moves on average
Possible average:~35 seconds
Goal for Average before Advancing: 60 sec, which comes out to a little less than 2 tps
(turns per second)

Step 2: 4-step last layer (2-step OLL and 2-step PLL)

The method described in Leyan's guide often solves each of the four steps of last layer
(edge orientation, corner orientation, corner permutation, and edge permutation) using more
than one algorithm. Our goal in this step is to combine these sub-steps so that each of the
four steps, in the same order, is now solved with just one algorithm. The list of required
algorithms, which is a subset of full OLL and PLL, are given on this page.

Algorithms needed: 16 last layer algorithms (3 edge orientation, 7 corner orientation, 2

corner permutation, 4 edge permutation)
Moves on Average: ~85 moves
Possible average: ~25 seconds
Goal for Average before Advancing: 40 sec (~2 tps)

Once you have memorized the algorithms, consult Getting Faster with an Easy Method for
tips on how to get down to 40 seconds.

Step 3: Fridrich for the Lazy Cuber

This is almost full Fridrich. Work on the following substeps simultaneously:

3a: 3-step last layer 3b: Standard F2L

(Full PLL) The method described in Leyan's
guide solves the first two layers by
Combine the 2-step PLL first solving the corners and then the
into one by learning the edges. F2L allows us to solve a
complete PLL. corner and an edge at the same
time, thus combining some of the
Algorithms needed: 31 steps within the first two layers and
last layer algorithms (the reducing the number of algorithms
same 10 orientation applied from a maximum of 8 to 4.
algorithms from Step 2 and Learn the standard F2L and the
15 new permutation basic techniques described on the
algorithms for a total of 21 F2L page.
PLL)
Algorithms needed: 41 F2L
"algorithms," many of which are
intuitive and short (only the first 3 or
4 moves are essential).

Although memorizing algorithms is of course important, at this stage looking ahead is much
more crucial to getting faster times. Once you are comfortable with the algorithms, start
praticing to look ahead. After learning both Steps 3a and 3b:

Moves on Average: about 63 moves

Possible average: 15 seconds
Goal for Average before Advancing: 25 sec (about 2.5 tps)

Step 4: Full Fridrich (Full OLL)

As in Step 3(1), we combine the two-step OLL into one by learning the complete OLL. This
step is simultaneously the least important and the one that requires the most memorization.
For cubers who are already very good at two-step OLL, learning these algorithms might only
improve their time by 2 seconds or so. Of course, it is a necessary step for becoming a
world-class cuber.

As you are learning OLL, continue to practice looking ahead. To achieve a sub-20 average,
a good goal is 3 tps.

Algorithms needed: 78 last layer algorithms (47 new orientation algorithms)

Moves on Average: 56 moves
Possible average: 11 seconds ??

Of course, it's not necessary to strictly follow this outline. Many people start learning OLL
earlier, and it's perfectly possible to mix the OLL algorithms you do know with two-step OLL for
cases you don't. Several cubers have learned the entire Fridrich method in less than three
months. Even with the high level of speedcubing in the last year years, because of the
increased availability of optimized algorithms and videos it's still possible to become a world-
class speedcuber in less than one year.

Memorizing Algorithms
Yes, the Fridrich Method does require you to memorize a large number of algorithms. Yes, it's
difficult to memorize and keep memorized the algorithms for many OLL cases that happen only
rarely. There are, however, things that can make the process less painful.

Relate patterns to one other, by shape, mirroring, inverses, finger tricks, etc. Breaking an
algorithm down into smaller substeps or two other patterns is also useful. For example, #12 on
my list is #45 twice with a y in the middle. While learning the algorithms, always keep a print-out
page handy for reference. Feel free to edit mine by putting in your own algorithms.

One good technique for memorization is to find key shapes or blocks of colors while excuting an
algorithm. For example, in doing RUR'URU2R', look at the block formed by the FRD corner and
the FR edge. As you excute the algorithm, this block moves up to the top layer and is rotated
clockwise 90 degree at a time before being placed back by a 180 degree turn and into the
starting position. It becomes much harder to find these things for a longer algorithm, but
knowing something peculiar about an algorithm help you reconstruct it as you go.

Another basic method is to "chunk" each algorithm into smaller pieces that can be excuted in
one move. Each chunk should be easy enough to memorize, and then all you need to do is to
piece them together to reconstruct the entire algorithm. Chunks can be any finger trick like
RUR', R'UR, or B'R'U.

Mnemonics can be useful for getting an algorithm to at least stick in your mind before getting it
internalized with muscle memory. Some people associate each move to a sound so that an
algorithm becomes a "word." While they can be helpful, these systems should only be thought
of as training wheels. Speedcubers need to be able to react instantaneously to any learned
case, so the memory needs to be in the muscle more than as letters or sounds. Also, splitting
up the moves by sound usually gives a different result than the grouping based on finger tricks.

Here's an analogy I like: mnemonics for a foreign language. I often use creative connections to
learn new words, and that fine for taking vocabulary tests in class. But it's not as useful in
conversation, where I have to come up with words very quickly and put them together in a
natural manner--kind of like finger tricks in speedcubing.

Of course, there's always repetition. This could be simplified with the help of a training program
like the last layer trainer.
Other Speedcubing Methods (to be edited)
Although most top speedcubers use a Fridrich-based method, there are a handful of cubers who
use very different methods. Sub-15 average has been shown to be possible with each of the
methods in this section.

Besides Jessica Fridrich, there are two other cubers who competed in the 1982 World
Championship in Hungary and has come back to compete after 2004. Each of them invented
their own method.

Razoux Shultz Method (CLL/ELL)

After completing the first two layers, this method finishes off the last layer in two steps, as in
Fridrich, but using CLL, which permutes and orients the corners, followed by ELL, which
permutes and orients the edges while preserving the corners. Since the Fridrich F2L is
usually used for the first two layers, this approach is used not as an entirely separate
method but as an alternative to Fridrich last layer. In this context, it is usually simply called
CLL/ELL.

Petrus Method
Invented by Lars Petrus, this method relies less on algorithms and more on building blocks;
the first step, for example, is to build a 2x2x2 block. At the same time that this is more
intuitive than Fridrich F2L, it usually takes longer to master all the various block building
techniques.

Waterman Method
Marc Waterman invented this advanced corners-first method during the first cube crazy. For
many years, his 17 second average remained one of the fastest in the world using any
method. Watermaan has not competed since the 80's. A description of this method can be
found at Rubikscube.info.

Roux Method
Gilles Roux invented this method in 2003 partly in reaction to the growing popularity of the
Fridrich Method, which relies on a large number of algorithms. Extending the block
approach of the Petrus Method even further, this method starts off with a pair of 1x2x3
blocks.
Beyond Fridrich(to be edited)
(hmm note the recurring idea of combining steps by adding more algorithms)

When I entered the world of speedcubing in 2002, sub-20 average was the holy grail achieved
only by a handful of speedcubers around the world. Over the next few years, this barrier
dropped to 17, 15, 14, and 13--times that many believed neared the limit of the Fridrich method.
While Fridrich has remained mainstream, cubers have developped a number of new system in
search for faster methods. Among these, what seemed the most logical extension of Fridrich
was Zborowski-Bruchem method, or ZB, which combined another step in the last layer by
dramatically increasing the number of algorithms.

Although several cubers attempted to learn ZB, or at least ZBF2L (the ZB version of F2L), as far
as I know there is no one as of yet who has memorized the full method. What's more, I, like
many, now doubt that ZB would improve the solving time significantly. Although the number of
moves used in ZB is very appealing, with such a large number of algorithms, it would take a
tremendous amount of time to optimize and master every single pattern to the extent that top
cubers have done for the Fridrich method. Now with the fastest cubers recording sub-12
averages with Fridrich, there is no longer any motivation to learn ZB.

So where will speedcubing go? What's the true limit of Fridrich, and is there another method
that can surpass Fridrich? These are the questions we're still trying to answer.
 Notation
This site uses the standard notation with the exception of the double-layer suffix "w" adopted
from the JSCC notation.

The six layers and three slices of the cube are indicated by the following capital letters:

Layers

U (Up) D (Down) R (Right) L (Left) F (Front) B (Back)

Slices

M (Middle) E (Equator) S (Side)

A layer and its adjacent slice together are denoted by the letter for the layer followed by "w":

Double Layers

Uw (Up double) Dw (Down double) Rw (Right double) Lw (Left double) Fw (Front double) Bw (Back double)

The colors are shown only for clarity. For example, "R" is the layer on the right (relative to the
cube's orientation) regardless of the current state of the cube or the position of the centers.

The notation for each move is constructed as follows:

(Double) layer or slice

Number of turns Direction of turn
name
+ +
(none) = Quarter turn (90 degrees) (none) = Clockwise
One of the fifteen listed
2 = Half turn (180 degrees) ' = Counter-clockwise
above
 Beginner Solution to the Rubik's
Cube
My speedcubing records | Rubik's 25th Anniversary

Translations: Italian | German | Spanish | Dutch

introduction | structure of the cube | cube notation

solution | first layer | cross | FL corners | middle layer | last layer
LL edge orientation | LL corner permutation | LL corner
orientation | LL edge permutation | next steps

 PDF version of beginner cube solution (requires Adobe Acrobat)

 Introduction

There are many different methods for solving the Rubik's cube. They can be divided into two broad
categories: layer methods and corners first methods (and there are sub-categories within these broad
categories). The method I use for speedsolving is a layer based method. More specifically, the method I
currently use is: cross, F2L, 3-look LL (I know some of the OLLs, so sometimes I can do a 2-look LL). If
you are a newbie cuber then this description may not mean much to you, so I should add that it's the
'Advanced Solution' I described in the Next Stepssection at the end of this page.

Many years ago when I wrote this webpage there were many great websites that explained advanced
and expert methods for solving the cube (check out my Rubiks links page), however, there were very
few that explained beginner methods. This is the reason I wrote this page. It's not meant to be a totally
comprehensive explanation, it's really just some notes I threw together for some friends I was teaching.
I thought it might be useful for others, so I've turned it into a webpage.

This beginner method requires memorising only a few algorithms, and when done efficiently can achieve
solves of 60 seconds or faster. I know people who can solve in 20-30s with a method like this. I haven't
been able to solve so fast with a beginner method, so don't be too distressed if you can't either. On the
other hand, if you can do 30s solves with this method, then you are too good for this method and you
should be learning an Advanced or Expert method!

Aside from minimal memorisation, another benefit of this method is that it is very scalable. More
algorithms may be added later to develop it into an advanced method, or if you're really keen, an expert
method. This means you don't need to scrap it and start again to move to an expert method. Everything
you learn here will be useful for more advanced methods.

 Structure of the cube

We all know that 3x3x3=27, however, rather than thinking about the cube as 27 little "cubies", think
about it as 6 fixed centres (that can rotate on their own axis) with 8 corners and 12 edges which rotate
around it. As the centres are fixed, the centre colour defines the colour for the face. It's important to
remember this otherwise you'll end up trying to do illogical (mechanically impossible!) things like
wondering why you can't work out how to put a corner piece in an edge position, or assuming that you're
looking at the blue face merely because 8 of the 9 cubies on it are blue (if the centre is white then it's
the white face).

 Terminology

When describing the solution for the 2nd and 3rd layers, standard cube notation will be used. Here's
what you need to know to read it:
 F = front face B = back face R = right face L = left face U = up face D = down face

In addition to a letter, each move may be accompanied by an apostrophe or the number two:

 A letter by itself means turn that face 90 degrees clockwise (eg. F).

 A letter followed by an apostrophe means turn that face 90 degrees anti-clockwise (eg. F').
 A letter followed by the number 2 means turn that face 180 degrees (direction is irrelevant),
(eg. F2).

So R U' L2 is shorthand for "turn the right face 90 degrees clockwise, then turn the up face 90 degrees
anti-clockwise, then turn the left face 180 degrees". When thinking whether to turn clockwise/anti-
clockwise, imagine that you are looking directly at the particular face you are turning.

For each algorithm, the notation is written with the assumption that the core of the cube remains fixed
throughout the whole algorithm, and the faces just turn around it. This means that you also need to
know how to position the cube to start the algorithm.

For pictures and further detail about cube notation, have a look at Jon Morris' cube notation page. 

The Solution

  The First Layer

The first layer is solved in two stages:

1. Form the cross

2. Insert the 4 first layer corners (each corner is inserted individually)

I believe that the first layer should be done intuitively. You need to understand it and solve it without
learning algorithms. Until you can do this, I wouldn't bother attempting the rest of the cube! So, spend
some time playing with the cube and familiarising yourself with how to move the pieces around the cube.

Now, here are some tips to get you started.

 The Cross

I prefer to start with the white cross because I find white easier to quickly identify on a completely
scrambled cube, however, you can use any colour.

There are 4 edge pieces with white (ie. the 4 arms of the cross) which have specific positions. You can't
put any white edge piece in an arm of the cross because the other colour on the edge cubie must match
up with it's centre on the middle layer.
Here is a pic of what a correctly formed cross looks Here's a pic on an incorrectly formed cross. Looking
like (grey denotes cubies that are irrelevant to the at the whiteface we do indeed see a white cross,
cross). Note that thewhite/red edge cubie matches however the white/red edge cubie does not match
up with the white centre and thered centre. Ditto up with the red centre. Ditto re
re the white/blue cubie. thewhite/blue cubie. This is bad!

For a detailed explanation of the cross, check out Dan Harris' Solving the Cross page.

 The First Layer Corners

Once you have completed the cross, completing the first layer requires inserting each of the 4 corners in
separately. The first thing to do is examine your cube and locate all of the top layer edge pieces - they
will be sitting in either the first layer or the last layer. Inserting the first layer corners should be done
intuitively, not by learning algorithms. To get you started, here's a step-by-step example of one way to
insert a first layer corner.

Step 1 Step 2 Step 3 Step 4

The blue/red/white corn Now your cube should Now that Now

er is sitting in the bottom look like this. Move the D the blue/white edge the blue/white/red corn
layer (theblue part is face 90 degrees anti- and er is in its correct place.
facing the bottom so we clockwise to line up the blue/white/red cor
can't see it in this theblue/white edge ner have been lined up,
picture). Turn with re-form thewhite cross
the blue face 90 degrees theblue/white/red corn by turning the blueface
anti-clockwise. er. 90 degrees clockwise.

Here are some tips for inserting the top layer corners:

 Start with a first layer corner that is sitting in the last layer.

 If there are multiple first layer corners in the last layer (there usually will be), start with one
that does not have the white part of the corner on the face opposite the white face. Or, if you were
using a different colour for the cross ('colour X'), start with a corner that does not have the 'colour X'
part of the corner on the face opposite the 'colour X' face.

 When working with a first layer corner piece that is in the first layer (but in the wrong first layer
corner position), you will need to get it out of the first layer into the last layer, then insert it into the
correct first layer corner position. The same principle applies if a first layer corner piece is in the
correct first layer corner position but needs to be flipped around. You need to get it out of the first
layer (ie. into the last layer), and then re-insert it into the first layer the correct way around.
 This is what the first layer should look like when finished.

  The Middle Layer

The middle layer consists of one stage:

1. Insert the 4 middle layer edges (each edge is inserted individually).

You only need to learn one algorithm (plus the mirror algorithm) for the second layer. There are many
more algs, but let's just learn the essential one first.

First, locate a middle layer edge that is currently sitting in the last layer. I'm going to use
the blue/red edge for this example.

This blue edge cubie in the last layer is the blue/red edge

cubie.

In this picture, U=white, L=red and F=blue. We can't see the other three faces, but obviously the R
face is the one opposite the L face, the D face is opposite the U face and the B face is opposite the F
face.

Now, position the blue/red edge piece so that the colour on the side of the cube (blue in this case) lines
up with it's centre. Now perform the following algorithm: D L D' L' D' F' D F

If the blue/red edge piece was flipped the other way so that the blue was on the bottom rather than
the red, you would position the cubie under the red centre and perform the following alg: D' F' D F D L
D' L'. This is the mirror of the previous algorithm. The axis of symmetry lies diagonally across the white
face, and along the line which divides the blue face and the red face.

What if the edge piece is not in the last layer?

The instructions above assume that the middle layer edge piece you are
inserting is sitting somewhere in the last layer.

If some middle edges are in the last layer and some are in the middle
layer in the wrong spot, always start working with the edge pieces that
are in the last layer. After you've done this, sometimes (but not too
often) you'll be left with a middle layer edge piece that's in the middle
layer but in the wrong spot. In this situation, you can use the same The red/blue middle
middle layer algorithms from above (D L D' L' D' F' D F or D' F' D F D L layer edge piece is in the
D' L') to insert another edge piece into the middle layer edge position, middle layer but not
thereby knocking the middle layer edge piece out of its spot and into the oriented correctly. It
last layer. Once you've done this, the middle layer edge piece is in the needs to be moved to the
last layer and you can deal with it in the usual way. last layer, then put back
into the middle layer in
There is a short-cut to this problem, but as this is a beginner solution
with minimal memorisation, I haven't included it here. If you really want the right way.
to learn it, take a look at Case Dd2 on Dan Harris' site.

  The Last Layer

The last layer ("LL") is done in 4 steps:

1. Orient the edges (2 algs) - i.e. form a cross on the D face.

2. Permute the corners (1 alg) - i.e. get the corners in the correct position in 3D space (don't
worry if they still need to be rotated).
3. Orient the corners (1 alg + mirror alg) - i.e. flip the corners.
4. Permute the edges (1 alg) - i.e. swap the edges around. The cube should now be solved! :)

All last layer algorithms are performed with the cross (i.e. the first layer - white side in this example) on
the bottom.

 Orienting the LL Edges

Once you have completed the first two layers ("F2L"), hold the cube so that the white side is on the
bottom. The white side will be on the bottom for the remainder of the solution. This means that the white
side is the D side for all last layer algorithms.

On my cube, white is opposite yellow, therefore yellow is the U face for all last layer algorithms on my
cube. Note that your cube may have a different colour opposite white (e.g. blue). Now have a look at
your last layer, and in particular, look at the last layer face - there are 4 possible patterns of LL edges
that you may see.

State 1 State 2 State 3 State 4

Unlike with the initial cross (where all the edges must match up with the white centre and with the
centres on the middle layer), here all you need to worry about is getting all the last layer edges matching
up with the last layer centre. It doesn't matter if the other colour on the LL edge piece does not match up
with the colour on the middle layer centre. Also, ignore the LL corners too. It doesn't matter what they
are doing at the moment. Now, let's consider each of these LL edge states separately.

State 1

All the edges are already oriented correctly. Move on to permuting the corners.
The two possible states are:

 two adjacent LL corners need to be swapped; or

 two diagonal LL corners need to be swapped.

These are the only two possible states. If you cannot identify one of these two states with your LL
corners then one or more of the following must be true:

 You have not finished the F2L.

 Someone has ripped out a corner of your cube and put it in the wrong way.
 Someone has ripped off some of your stickers and put them back in the wrong place.
 You are not looking hard enough. ;)

Swapping adjacent corners

Hold the cube with the white side on the bottom, and the two corners to be swapped are in the front
right top and the back right top positions. Perform the following algorithm: L U' R' U L' U' R U2. To see
an animated version of this algorithm, see the first algorithm on Lars Petrus'Step 5 page. On Lars' site,
the algorithm is being executed from a slightly different angle (the two corners being swapped are front-
top-right and front-top-left), but it is the same exact algorithm.

Swapping diagonal corners

Swapping diagonal corners can be done by executing the adjacent corner swap algorithm twice. Perform
it once to swap any two LL corners. Re-examine you cube and you'll see that now there are just two LL
corners that need to be swapped. Position it correctly for the final LL adjacent corner swap and perform
the LL adjacent corner swap algorithm.

 Orienting the LL Corners

There are 8 possible orientation states for the LL corners. One is where all 4 corners are correctly
oriented. The other 7 look like this.

State 5 State 7
State 4 State 6
State 1 State 2
State 3

State 1. Twisting three corners anti-clockwise

R' U' R U' R' U2 R U2

State 2. Twisting three corners clockwise

R U R' U R U2 R' U2 

To see an animated version of this algorithm, look at Lars Petrus' Sune algorithm.
States 3-7

Once you know the algorithms for States 1 and 2, you can solve any LL orientation State. The remaining
States can be oriented using a maximum of 2 algorithms. You will need to do one of the following (i) the
State 1 algorithm twice, (ii) the State 2 algorithm twice, (iii) the State 1 algorithm, then the State 2
algorithm, or (iv) the State 2 algorithm, then the State 1 algorithm.

In a previous edition of this solution, I had said that I'm not going to tell you exactly how to combine the
State 1 and State 2 algorithms to solve States 3-7. My reason for this was because it is important that
you try to understand how the State 1 and the State 2 algorithms work, and that once you do
understand them you will be able to work out how to use them to solve all the States. I still believe this,
however, I received emails from a few people who were having trouble with States 3-7, so I decided to
write some extra tips. I still suggest that you try to work out States 3-7 by yourself, but if you are really
stuck, have a look here: Orienting the Last Layer Corners: further tips.

 Permuting the LL Edges

There are 5 possible permutation states for the LL edges. One is where all 4 edges are correctly
permuted. The other 4 look like this.

State 1 State 2 State 3 State 4

R2 U F B' R2 F' B U R2 R2 U' F B' R2 F' B U' Apply the algorithm for Apply the algorithm for
R2  either State 1 or State 2. either State 1 or State 2.
This is almost identical to Re-examine your cube Re-examine your cube
the algorithm for State 1. and it will now look like and it will now look like
Only difference is the State 1 or State 2. State 1 or State 2.
2nd move and the 2nd
last move.

For an animated version

of this algorithm, see
the Lars Petrus' Allen
algorithm. The algorithm
is being executed from a
slightly different angle,
but it is the same exact
algorithm.

And that's all you really need to know to solve the Rubik's Cube! With practice, you should be able
to achieve times of 60 seconds (or faster) using this method. Once your comfortable with this method
and want to learn more, take a look at the following section.

  Next Steps
If this beginner method is too easy and boring for you then consider the following.

 Intermediate method

 Solve each first layer corner + corresponding middle layer edge in one step. This means that
after the cross you only have 4 steps (4 corner/edge pairs) to complete the F2L. With this beginner
method there are 8 steps: solve each of the 4 first layer corners, then solve each of the 4 middle
layer edges. I'd suggest just playing around with your cube and figuring out the F2L corner/edge
pairs yourself. For some hints about solving the F2L intuitively, have a look at Doug Reed's
intuitive F2L guide. If you're still stuck and just want the algorithms, check out Dan Harris' F2L
page and Jessica Fridrich's F2L page.
 

 Learn the 4 specific algorithms (or rather, 3 algorithms plus one mirror algorithm) for each of
the 4 different permutation states of the LL edges. My beginner solution already shows you 2 of the
4 last layer edge permutation algorithms, the other two last layer edge permutation algorithms
are Case #5 and Case #17 on Dan Harris' PLL page.

 Advanced method

 Learn everything from the Intermediate method.

 Learn the 3-look LL. This requires learning the 7 specific algorithms for the 7 different
orientation states of the LL corners, and learning the 21 PLL algorithms (permuting the last layer
algorithms) so you can permute the LL edges and LL corners at the same time. A full 3-look LL uses
30 algorithms.

For more details about the advanced method, check out t Rubiks Galaxia 3-look LL, Dan Harris'
site and Lars Vandenbergh's PLL page.

 Expert method

 Do the F2L in 5 steps (first dot point from the Intermediate method).

 Learn a full 2-look LL. This requires memorising 21 PLL algorithms, plus 57 OLL algorithms
(orienting the last layer algorithms).

For more details about the expert method, check out Dan Harris' site, Joël van Noort's site and Lars
Vandenbergh's site.

 Other stuff

The method I've documented here is what I believe to be a good beginner method. The problem with
some beginner methods is that they are not scalable - to improve your cubing you have to un-learn
much of what you know and re-learn it in a different way. This method focuses on memorising very few
algorithms, but is structured in a way that allows for development into an intermediate or advanced
method. Other thing I should say is that I didn't actually devise any of the last layer algorithms in this
method. I merely chose a selection of existing algorithms (sourced from a variety of places
including Jessica's site and Dan K's site) and organised them into a simple solution method.

 Celebrate your cubing success!

When you are confident that you can solve the cube by yourself, time yourself so you can keep track of
your progress. Also, consider submitting your time to the unofficial world records.

 You are cuber number...

 
 ... to visit this page 

Home | My speedcubing records | RWC2003 | Rubiks Links | Rubik's 25th Anniversary | 

Page last modified Saturday 31 January 2010 by Jasmine Lee 

An Overview of the Fridrich Method

Notice
The Fridrich Method is quite advanced. Unless you already
average near 30 seconds and want to get under 20 seconds, go
to the general speedcubing page instead.

Online gaming has become more and more popular. Enjoy playing with the top online casino.

Invented by Jessica Fridrich in the early 1980s, the Fridrich Method gained popularity among
the second generation of speedcubers when it was published online in 1997. By far today's
most popular speedcubing method, it is used by most world-class speedcubers with minor
modifications.
Applets on this site use the Japanese color scheme (blue opposite white) by default. The setting
can be changed here.

Cross
Solve the four edges of one layer (bottom layer shown). 

~8 moves, ~2 seconds

F2L (First Two Layers)

Complete the first two layers by solving the four corner-edge pairs between the cross edges in
four steps, one slot at a time. 41 standard patterns counting mirrors for corner-edge pairs. 

~7 x 4 = 28 moves, ~6 seconds 

Advanced F2L

OLL (Orientation of Last Layer)

Correct the orientation (flip) of all last layer pieces in one step so that every piece has the last
layer color on top. 57 patterns counting mirrors and inverses. 

~9 moves, ~2 seconds 

Printable page

PLL (Permutation of Last Layer)

Correct the permutation (placement) of all last layer pieces in one step. 21 patterns counting
mirrors and inverses. 

~11 moves, ~2.5 seconds 

Printable page

Orientation of Last Layer (OLL)

 Printable Page (select "landscape" in page set-up)

First of the two last-layer steps, OLL corrects the orientarion of all last layer pieces in one step
so that all U-stickers have the U-color. Permutation is not preserved.

The images represent the last layer, with a gray square or a black side bar indicating U-stickers.
Each algorithm applies with this layer as U; click on any algorithm to view it on an applet. Most
of these algorithms have been taken from or are based on those by other cubers. Try other
lists to find your favorite.

Recognition
The placement of the correctly oriented last-layer pieces are easy to see, so recognition
depends on being able to quickly tell between different patterns with the same top view. It helps
to practice recognizing each pattern from the top and two adjacent sides.

Learning OLL
OLL has the lowest speed increase per case learned of all steps of the Fridrich method; a 25-
second cuber may only gain 2 seconds by replacing an efficient two-step OLL by full OLL (47
additional algorithms). Although any serious CFOP user should learn eventually learn full OLL, it
should be noted that working on better F2L look-ahead is a more efficient way to get faster.

The algorithms are organized by similarity to aid memorization. See the printable page for the
original order.

2-Step OLL
Before you even begin considering full Fridrich, you should know 2-look OLL. These account for
10 out of the 57 cases.

Edges
OLL 45 (6-move T): 1/54

FRUR'U'F'

The easiest OLL

OLL 44: 1/54

FwRUR'U'Fw'

Fat (double-layer) 6-move T

(U2)FURU'R'F'

Inverse of 6-move T

OLL 1: 1/108

RU2'R2'FRF'-U2'R'FRF'

remove-play-reinsert

Corners
OLL 27: 1/54

RUR'URU2'R'

(Right) Sune

OLL 26: 1/54

R'U'RU'R'U2R / (U2)L'U'LU'L'U2L

Sune
 R'ULU'RUL'

Niklas. Good when the top left 2x2 is a block.

(U')RU2'R'U'RU'R'

Anti-Sune

OLL 21: 1/108

RU-R'URU'R'URU2'R'

Double Sune. Sune twice with cancellation of R'-R.

(U)RU2'R'U'RUR'U'RU'R'

Double anti-Sune

OLL 22 ("The Wheel"): 1/54

RU2'R2'U'R2U'R2'U2'R

The fingertrick here is called the Air Jeff, after my friend Jeff Black. Hold the R layer with all five
fingers, four on top and the thumb on bottom. This grip never changes. Do R, double trigger U2' with
the left index finger, R2', left trigger U', etc. The key is to alternate the direction of R2.

OLL 23 ("Headlights"): 1/54

R2DR'U2RD'R'U2R'

Video by TellerWest. Probably should use a simpler fingertrick.

(U2)R'UL'URU'L-U2'R'UR
 Best for OH

OLL 24: 1/54

RwUR'U'Rw'FRF'

(U2)Lw'U'LULwF'L'F

Mirror. Nice to know.

OLL 25 ("The Finger"...ask Bob Burton): 1/54

Lw'U'L'U-RU'LUx'

(U2)Rw'U'RU-LU'R'Ux

Mirror. Nice to know.

The 6-Move T Group

Many OLL algorithms can be grouped by similarity. You already know 45 and 44 from 2-step
OLL; they are replicated here for reference. This group contains the various algorithms made by
combining their mirrors and inverses.

OLL 45 (6-move T): 1/54

FRUR'U'F'

The easiest OLL

OLL 44: 1/54

 FwRUR'U'Fw'

Fat (double layer) 6-move T

(U2)F-URU'R'F'

Inverse of 6-move T

OLL 43: 1/54

F'-U'L'ULF

Mirror of 44

(U2)Fw'L'U'LUFw

Same algorithm

OLL 2: 1/54

FRUR'U'F'-FwRUR'U'Fw'

Pull F and Fw with right index. Push F' and Fw' with right thumb. Keep the thumb on F center.

Rw'U'RwR'U'RU'R'URU2'Rw'URw

Sébastien Felix's. Just as good. Better for OH.

(U)RwURw'U2'RU2'R'U2'RwU'Rw'

Jeremy Fleischman's. This and mirror both great for OH.

OLL 48: 1/54

 FRUR'U'RUR'U'F'

Double 6-move T (F'-F cancelled)

OLL 47: 1/54

R'U'xR'URU'R'URU'x'UR

For righties, safer than the mirror of 48, F'L'U'LUL'U'LUF.

Bw'-U'R'URU'R'URBw

Maybe better

(U2)Rw'F'L'ULU'L'ULU'FRw

Sébastien Felix's

OLL 3: 1/54

FwRUR'U'Fw'-U'-FRUR'U'F'

Fat 6-move T, U', 6-move T

(U2)FURU'R'F'y-FRUR'U'F'

Variation

(U')R'RwU-Rw'U2-RwU-R'UR2Rw'

Old school, but great.

(U)M-RUR'URwU2'Rw'-UM'
 Easier to understand (note Sune-like part). Nice for OH.

OLL 4: 1/54

FwRUR'U'Fw'-U-FRUR'U'F'

Fat 6-move T, U, 6-move T

R'U2x-R'URDw'-R'U'R'UR'Fy'x'

Old school, but good.

(U')M'-R'U'RU'Rw'U2'Rw-U'M'

Easier to understand. Nice for OH.

You just learned 7 new algorithms, bringing the total to 17.

The Sune Group

These algorithms are all similar to Sune (OLL 26/27 from 2-Step OLL), which are replicated at
the top. It shouldn't be too hard to learn these rotated by U2.

OLL 27: 1/54

RUR'URU2'R'

Sune. Mirror of 26.

OLL 26: 1/54

R'U'RU'R'U2R / (U2)L'U'LU'L'U2L
 Sune

R'ULU'RUL'

Niklas. Good when the top left 2x2 is a block.

(U)RU2'R'U'RU'R'

Anti-Sune

OLL 7: 1/54

RwU-R'URU2'Rw'

Fat Sune

(U2)LwUL'ULU2'Lw'

Same algorithm

OLL 8: 1/54

Rw'U'RU'R'U2'Rw

Fat Sune

(U2)Lw'U'-LU'L'U2Lw

Same algorithm

OLL 54: 1/54

RwU-R'URU'R'URU2Rw'
 Fat double Sune

(U2)LwUL'ULU'L'ULU2'Lw'

Same algorithm

OLL 53: 1/54

Rw'U'RU'R'URU'R'U2Rw

Fat double Sune

(U2)Lw'U'LU'L'ULU'L'U2Lw

Same algorithm

OLL 6: 1/54

RwU2'R'U'RU'Rw'

Fat anti-Sune

(U2)RB2'y-B'R'BR'F'

Same algorithm

OLL 5: 1/54

Rw'U2'RUR'URw

Fat anti-Sune

(U2)Lw'U2'LUL'ULw
 Same algorithm

OLL 9: 1/54

M-RU2'R'U'RU'R'-U'M'

M then anti-Sune. Actually more like Rw'R2U2'...

(U)RUR'U'R'FR2UR'U'F'

Jeremy Fleischman taught me this. OLL 33 (the other T) then 6-move T.

(U)R'U'Ry'-RB'R'URBR'

Older, but also pretty good.

OLL 10: 1/54

M'-R'U2'RUR'UR-UM

M' then anti-Sune. Actually more like Rw'R2'U2'...

(U')RUR'y-R'FRU'R'F'R

Older, but also pretty good.

(U')RUR'UR'FRF'RU2'R'

No rotation, but is it worth it?

OLL 11: 1/54

M-RU-R'URU2'R'-UM'
 M followed by Sune. Actually more like Rw'R2U...

(U2)RwU-R'UR'FRF'RU2'Rw'

OLL 12: 1/54

M'R'U'RU'R'U2'R-U'M

M' followed by Sune. Actually more like RwR2'U'...

(U)FRUR'U'F'-y-FRUR'U'F'

6-move T twice. Actually more like FRUR'Dw'-L'FRUR'U'F'

OLL 41: 1/54

RUR'URU2'R'-FRUR'U'F'

Sune then 6-move T

(U2)RU'R'U2'RUy-RU'R'U'F'

Old school, but actually all right from this direction

OLL 42: 1/54

R'U'RU'R'U2'R-FRUR'U'F'

Sune then 6-move T

(U)R'FRF'R'FRF'-RUR'U'RUR'

Just as good
OLL 51: 1/54

FwRUR'U'RUR'U'Fw'

Double fat 6-move T (Fw-Fw' cancelled)

(U2)F-URU'R'URU'R'F'

That's 12 more cases! We're already at 29 OLL cases.

Remove-(Play)-Reinsert
Consider how the Sune (RUR'URU2'R') affects the FR F2L pair: RUR' removes the pair to the
last layer and URU2'R' reinserts it differently, so that overall only the last layer is affected. A
similar analysis applies to OLL 1 (RU2'R2'FRF'-U2'R'FRF'): RU2'R'removes the FR pair;
R'FRF'U2' plays only with last layer pieces; and R'FRF' reinserts the pair. Combining different
ways to remove, play, and reinsert an F2L pair gives rise to a number of good OLL algorithms,
and this analysis makes them easier to memorize.

OLL 33: 1/54

RUR'U'-R'FRF'

Remove-reinsert

R'U'RU-LwU'Lw'U

Better if certain blocks are present

OLL 37: 1/54

B'RBR'-U'R'UR
 Remove-reinsert. Inverse of 33.

(U)FRU'R'U'RUR'F'

OLL 36: 1/54

R'U'RU'R'URU-RB'R'B

Remove-play-reinsert the BR pair. Starts like a Sune from the back.

(U2)L'U'LU'L'ULU-LF'L'F

Same algorithm

OLL 38: 1/54

RUR'URU'R'U'-R'FRF'

Mirror of 36

(U2)LUL'ULU'L'U'-L'BLB'

Same algorithm

OLL 57: 1/108

RUR'U'-RwR'URU'Rw'

Remove-reinsert

OLL 28: 1/54

 RwUR'U'R-Rw'URU'R'

Inverse of 57

OLL 17: 1/54

RUR'U-R'FRF'U2'-R'FRF'

Remove-reinsert as in 33, play in between.

OLL 1: 1/54

RU2'R2'FRF'-U2'R'FRF'

Remove-play-reinsert

OLL 35: 1/54

RU2'R2'FRF'-RU2'R'

Remove-play as in 1, reinsert differently.

OLL 18: 1/54

 RU2'R2'FRF'-U2'RwR'URU'Rw'

Remove-play as in 1, reinsert as in 57.

(U')RwU-R'URU2'Rw2'U'RU'R'U2'Rw

Two fat Sunes

That's 9 more algorithms, bringing the total to 36 out of 57. This is where things start to get
tough.

The Rest
Although these algorithms don't fit exactly into the "move around one corner-edge pair"
paradigm, many can still be analyzed in a similar way by splitting into recognizable fragments.
Some of the last few are especially tricky.

OLL 46: 1/54

R'U'R'FRF'-UR

Moves the BR pair

RURB'R'B-U'R'

Better depending on blocks present

OLL 52: 1/54

R'U'RU'R'-Dw-R'URB

OLL 13: 1/54

 LF'L'-U'-LFL'-F'UF

Inverse of the non-Sune alg for 9

FURU'R2F'RURU'R'

from badmephisto

OLL 14: 1/54

R'FR-U-R'F'R-FU'F'

Inverse of the non-Sune alg for 10.

OLL 15: 1/54

L'B'L-R'U'RU-L'BL

Move the DBR-BR pair (not an F2L pair, but similar analysis applies)

(U2)LwU'Lw'LU'L'ULw'ULw

Same algorithm

OLL 16: 1/54

RBR'-LUL'U'-RB'R'

Mirror of 15

(U2)RwURw'RUR'U'RwU'Rw'

Same algorithm
OLL 39: 1/54

RB'R'U'RU-BU'R'

(U2)LF'L'U'LUFU'L'

Same algorithm

OLL 40: 1/54

R'FRUR'U'F'UR

Mirror of 39

(U2)L'B'LUL'U'-B'UL

Same algorithm

OLL 32: 1/54

RUB'U'-R'URBR'

Inverse of 39

OLL 31: 1/54

R'U'F-URU'R'F'R
 Inverse of 40

(U2)L'U'BU-LU'L'B'L

Same algorithm

OLL 19: 1/54

MU-RUR'U'Rw-R2'FRF'

Rw'U2'RU-R'URw2U2'R'U'RU'Rw'

Fat double Sunes. Easier to learn, probably just as good.

OLL 20: 1/216

MU-RUR'U'-Rw2R2'URU'Rw'

OLL 34: 1/54

RUR'Dw'-R'F'*RwURw'Ry'

(U2)FRUR'U'R'F'RwURU'Rw'

From Algobase. Note resemblance to OLL 56 first algorithm.

OLL 56: 1/108

 FRUR'U'RF'-RwUR'U'Rw'

Starts like 6-move T, ends like 19

Rw'U'RwU'R'URU'R'URRw'URw

Just as good. Better for OH.

OLL 29: 1/54

B'R'BL'-B'R2B'R'B2'L

(U')M'U'Rw'FRU2'Rw2'FRwU'Rw

(U2)R2'U'RFR'UR2U'R'F'R

The Connie OLL. A lesson in non-standard fingertricks. Start with right thumb on F so that RFR' is
done without regrip, then U with left index push usually used in OH.

(U)RwUR'U'LwL2'URU'M'

Got this one from Vincent Sheu. Also tasty.

(U)RUR'U'RU'R'F'U'FRUR'

Play with FR pair. F' with right index push = no regrip.

OLL 30: 1/54

BLB'R-BL2'BLB2'R'

Mirror of 29, first algorithm

R2UR'B'RU'R2'URBR'

The Connie OLL. Starting with the RH as if after R2', R2UR'B'RU'-R2'URBR with RH ring finger B' and
180 regrip at the dash. Also several ways to do this without regrip (all using an index push), but not as
nice as in 29.
 (U2)FR'FR2U'R'U'RUR'F2

From Algobase

OLL 49: 1/54

RB'-R2'FR2BR2'F'R

Close to RwU'-Lw2'ULw2ULw2'U'Lw.

OLL 50: 1/54

L'B-L2F'L2'B'L2-FL'

Close to Rw'U-Rw2U'Rw2'U'Rw2URw'

Rw'URw2'U'Rw2U'-Rw2URw'

Same algorithm. Maybe better fingering.

OLL 55: 1/108

RwU2R'U'R2Rw'UR'U'RwU'Rw'

David Calvo Vivas's secret algorithm. No regrip!

(U)RU2'R2'U'RU'R'U2'FRF'
 Orientation of Last Layer (OLL)
1 2 F- 3 4
R'RwU-
RU2- RUR'U'- R'U2x-
Rw'U2-
R2'FRF'U F'-Fw- R'URU'y-
RwU-
2'-R'FRF' RUR'U'- R'U'R'UR'F
R'UR2Rw'
F'w
5 6 7 8
RwU-
Lw'U2'LU RwU2'R' Lw'U'-
R'URU2'R
L'ULw U'RU'Rw' LU'L'U2Lw
w'

9 10 11 12
F'U'F- FUF'- L'R2BR'B F-RUR'U'-
LF'L'-U- R'FR-U'- R- F'-y-F-
LFL' R'F'R B2R'BR'L RUR'U'-F'

13 14 15 16
R'FR-U- L'B'L- RBR'-
LF'L'-U'-
R'F'R- R'U'RU- LUL'U'-
LFL'-F'UF
FU'F' L'BL RB'R'

17 18 19 20
RU2- MU-
RUR'U- MU-
R2'FRF'- RUR'U'-
R'FRF'U2 RUR'U'Rw
U2'RwR' Rw2R2'UR
-R'FRF' -R2'FRF'
URU'Rw' U'Rw'

21 RU- 22 RU2'- 23 R2DR'U2 24 RwUR'U'R

R'URU'R' R2'U'R2 RD'R'U2R' w'FRF'
UR-U2R' U'R2'-
 U2R

25 26 27 28

Lw'U'L'U- L'U'LU'L' RUR'URU RwUR'U'R-

RU'LUx' U2L 2R' Rw'URU'R'

29 30 31 32
B'R'B-L'- BLB'-R- L'D'w- RDw-
B'R2B'- BL2B- RDw- L'D'w-
R'B2L LB2R' LU'L'B'L R'URBR'

33 34 35 36
RUR'U'(x RU2-
RUR'U'- R'U'RU'R'U
)-D'- R2'FRF'-
R'FRF' RU-RB'R'B
R'UR-E' RU2R'

37 38 39 40
LUL'ULU'
B'RBR'- LF'L'U'LU R'FRUR'U'F
L'U'-
U'R'UR FU'L' 'UR
L'BLB'

41 42 43 44
RU'R'U2 L'ULU2L'
F'wL'U'LU FwRUR'U'F
RU(y)RU' U'(y')L'U
Fw 'w
R'U'F' LUF

45 46 47 48
RU- F'- F-
FRUR'U'F
RB'R'B- L'U'LUL'U' RUR'U'RUR
'
U'R' LU-F 'U'-F'

49 50 51 52
Rw'URw
LwU'Lw2' F-
2U'Rw2' R'U'RU'R'-
ULw2UL URU'R'UR
U'R2wUR Dw-R'URB
w'2U'Lw U'R'-F'
w'
 53 54 55 56
RwU- RwU2R'U' F-
Lw'U'-
R'URU'R' R2Rw'UR' RUR'U'RF'-
LU'L'ULU'
URU2- U'RwU'Rw RwUR'U'R
L'U2-Lw
Rw' ' w'

57
RUR'U'-
Rw- Shotaro makisumi
cubefreak.net
R'URU'R smakisumi at gmail
w'

Permutation of Last Layer (PLL)

 Printable page (select "landscape" in page set-up)

PLL, the last step of the Fridrich Method, permutes all last layer pieces without disturbing their
orientation. While there are only 21 patterns (with mirrors and inverses), PLLs are longer on
average than OLLs. Go as fast as you can. First aim for sub-2.5 (sub-10 for 4 consecutive
executions) for each case.

Here you can find the algorithms I use. Do check out other cubers' lists to find your best match.
Even for the same algorithm, try chunking into different substeps or changing the grips. Keep in
mind that you don't need to worry about cube turns and that you need to put down the cube to
stop the timer. My OH algorithms are mostly from Jeremy Fleischman, who got some of them
from Dan Dzoan and Chris Dzoan.

(You might be thinking, "aren't you then allowing the method of timing to influence, if only
slightly, the method?" Yes! The 100-meter dash analogy shows why this is
reasonable: here, here, and here.)

My best PLL execution time (all 21 PLLs in a row): ~41. Watch Harris Chan do it in 36.83 and in
Hiroyuki Take in 35.02 seconds..

Recognition and AUF

Recognition takes longer for PLL than for OLL because we often need to adjust the U face
(AUF) before we can determine the case. Rather than systematically matching corners or
edges, I recommend using "blocks" for recognition. Refer to your keyboard's numpad for the
following description (props to Timothy Wang for the idea). Cycles describe the permutation.

Two adjacent top-layer pieces are connected if they have the same color on the same side.
Each permutation has a unique pattern of connected pieces that form blocks. For example, (46)
(39), the T permutation, has blocks 12 and 78. (37)(48), the Y permutation, has blocks 12 and
69--also two 2x1 blocks, but in a different arrangement. We recognize each case by its
particular pattern of blocks.

Learning the block pattern for each permutation allows us to do recognition often from two
adjacent sides. For instance, if you see the block 1236 (not connected to 9), the only possible
case is (79)(48), a J-perm. Sometimes, we need more information. Say you see the block 236
(not connected to either 1 or 9). There are three possible permutations: (19)(48), (179), and
(197). We can distinguish between these patterns by inspecting one of the two remaining
sides. Note: It is always possible to do recognition from two adjacent sides. Take the same
block 236. With (19)(48), the colors of 1 and 23 and those of 9 and 63 are opposite. For the
three cycle, only one set is opposite and the other is adjacent, on F or on R depending on the
direction. I personally find this too cumbersome.

If there is only one block, consisting of a corner and an edge, you have a G-perm. Match this
block with the first two layers to determine which of the four you have. If there is no block at all,
you have the E-perm, and matching any edge (which automatically matches all the edges)
shows which corner pair need to be switched.

An advantage of this recognition method is that you can sometimes see blocks coming together
during OLL. When this happens, by slowing down slightly towards the end of OLL, you can
predict the PLL and reduce the pause between the two last layer steps.

If you're sub-15, see Sébastien Felix's R-OLL for a much more sophisticated PLL-prediction

method.

Learning PLL
Start by learning two-step PLL, which is a subset of the complete PLL. There are two algorithms
for corners (n3 and n15) and four for edges (n1, n2, n5, n6). Learn n4, the reflection of n3. Of
the algorithms above, n15, which is used to swap corners across a diagonal, takes the longest.
For this reason, the next PLL cases to learn are the other cases with a diagonal corner swap:
n7, n9, n20, n21. From there, it's all preference. The intimidating G permutations are actually
not any more difficult to recognize than the other cases.

Algorithms
Only Edges
PLL n1a (U): 1/18
 R'UR'U'-R'U'-R'URUR2

zU2'RURU'R'U'R'U'RU'z'

For OH. Mirror of n2a.

PLL n2a (U): 1/18

R2U'R'U'RU-RURU'R

Inverse of n1a, first algorithm.

PLL n1b (U): 1/18

RU'RU-RURU'R'U'R2

Mirror of n1a. First-timers can ignore n1b/n2b, but they help since AUF and cube rotation are relatively
significant for easy PLLs.

PLL n2b (U): 1/18

R2U-RUR'U'-R'U'-R'UR'

Mirror

zU'RU'R'U'R'U'RURU2z'

For OH. Mirror of n1b, first algorithm.

PLL n5 (Z): 1/36

 UR'U'RU'RURU'R'URUR2U'R'U

Fast two-gen. For OH, replace first and last U with U'.

(y)R'U'RU'RURU'R'URUR2U'R'U2

U cycled to the end

U'M'UM2UM2UM'U2M2

Fast slices. Saw this credited to fanwuq. Can also cycle U'.

PLL n6 (H): 1/72

M2'UM2'U2M2'UM2'

Several possible M2' fingerings: the Bob Burton double trigger (left-hand ring middle), Rw2(R'M') with.
Or R2'Rw2U'L2Lw2'U2R2'Rw2U'L2Lw2'.

R2U2'RU2'R2U2'R2U2'RU2'R2

For OH. Reduction to R2U2'R2U2'R2U2'.

Adjacent Corners (Except Gs)

PLL n4 (Acw): 1/18

xR'UR'DDRU'R'DDR2x'

The Rowe Hessler Acw. No regrip, DD as left ring twice.

(y)x'R2DDR'U'RDDR'UR'x

(y')RUR'F'*RwUR'-U'Rw'FR2U'R'

Thick J

PLL n3 (Accw): 1/18

 xR2'DDRUR'DDRU'Rx'

The Rowe Hessler Accw.

PLL n8 (T): 1/18

RU*R'U'R'FR2-U'R'U'RUR'F'*

Left thumb on F throughout

(y2)U2'RU*R'U'R'FR2U'R'U-F'L'UL

Left-handed T.

RUR'U'R2z'RU'zU'R'U'RUR2z'R'Dw

The Robert Yau OH T

PLL n10 (F): 1/18

R'U'F'*RUR'-U'R'FR2-U'R'U'RUR'UR

F en T

(y)R'U2R'Dw'-R'F'R2U'R'UR'FRU'F

F en V

(y')R'URU'R2'F'U'F-URU'x'R2U'R'U

Old F, but with less rotation

PLL n11 (Ra): 1/18

 R'U2'RU2'-R'FRUR'U'-R'F'R2U'

(y2)zRU'RURU'R'U'L'URU'LUR2Uz'

For OH

PLL n12 (Rb): 1/18

(U')RU2'R'U2-LwU'L'wU'RULwULw'R'

Mirror of n11

U'RU'R'U'RURD-R'U'RD'R'U2'R'

Maybe better. Must for OH, but as -R'U'RUw'zx'-U'R2U' after the hyphen.

PLL n13 (Ja): 1/18

RU2'R'U'RU2'-L'UR'U'L

RUR'F'*RUR'-U'R'FR2U'R'U'

T-perm like. With right-index push for F', faster than the first alg. Cycle U' to beginning for another
angle.

PLL n14 (Jb): 1/18

R'U2'RUR'U2'-LU'RUL'

Mirror of n13
 R'U2RUR'z-R2'UR'DRU'

Same, but with a funky fingering

xU2'Rw'U'RwU2'-Lw'UR'U'R2x2

Optimal.

Opposite Corners
These cases tend to be more difficult.

PLL n9 (V): 1/18

R'UR'Dw'-R'F'R2U'R'UR'FRF

By Stefan Pochmann. Keep the thumb on F center except at the hyphen, where you need to move it
from L to F.

(y)zU'RDR'URU'Rz'-R'U'LU2'RU2'R'

Great for OH.

R'Uz'RU'RU2R'U'R2U'zU'Rz'R'U'R2U

For OH.

R'UR'Dw'z-U'RU'R'-Dw2R'URUR

Old. Still good for OH.

PLL n15 (Y): 1/18

R2U'R'U(RU'x')z'-L'U'RU'R'U'LU

Also definitely (y2)L2U'L'ULU'x'z-L'U'RU'R'U'LU (same ending), maybe R2'URU'R'Ux'z-RUL'ULUR'U'.

R2U'R'URU'x'-U'R'DR'D'R'UR

Same algorithm. For OH.

 FRU'R'U'RUR'F'*RUR'U'-R'FRF'

Two OLLs.

U'x'-U'RUR'x'z'-R'U'RU2'RU'R'y-U'RUR'

Jeremy Fleischman's OH

PLL n20 (Nb): 1/72

R'UR'FRF'RU'R'F'UF-RUR'U'R

Inverse of Stefan Pochmann's (his is also nice).

U'R'UL'U2'RU'R'LUL'U2'RU'L

Variat of (R'UL'U2RU'L)*2U. For OH.

PLL n21 (Na): 1/72

U-LU'R-U2'L'ULR'U'RU2'L'UR'

Also for OH.

RUR'URUR'F'RUR'U'R'FR2U'R'U2RU'R'

Conjugated J (set-up RUR'U). 21 moves.

PLL n7 (E): 1/36

x'RU'R'DRUR'D'RUR'DRU'R'D'x

The Rowe Hessler E. Left ring for D, keep it in place, push back for D'!

x'U'RU'Rz'RU'Rwxz'-RU'RURDR'U'R
 Robert Yau OH E

(y)x'RU'RU'z'U'RUw'zx'-U'RU'R'U'zU'RDR'

Robert Yau OH E

G perms
Yeah, G perms look scary. Each one has a single 1x1x2 block. Tell them apart by looking at the
location of this block relative to the two correctly permuted corners. Another recognition method
is to use the side sticker of the unique edge that extends this block to a 1x2x2. For example, for
n16 in the figure below, the FU and FUR stickers are opposite in color, while in n17, RU and
RUB are adjacent.

The French Gs (see Sébastien Felix's PLL) all start with the two good corners on the left and
use singe instead of double layer turns (but essentially the same algorithms). Some of them are
worth learning, especially when the two corners on the left are in the right place (i.e. no AUF).

PLL n16 (Ga): 1/18

RUR'y'-R2Uw'RU'R'U-R'UwR2

The second regrip can be omitted, but David Gomes calls the resulting right-index push for Uw "The
Elbow" for its (lack of) accuracy.

PLL n18 (Gb): 1/18

R'U'R(UD')R2U*-R'URU'RU'R2'D(U')

French G

R'U'Ry-R2UwR'URU'RUw'R2

Mirror of n16. Best for OH. For 2H, use R2' as appropriate. The first three moves can also be done as
x'Uw'R'Uwx.

PLL n17 (Gc): 1/18

 R2'Uw'RU'RUR'-Uw-R2'FwR'Fw'

(y2)R2'F2RU2'RU2'R'FRUR'U'R'FR2

From Erik Akkersdijk.

PLL n19 (Gd): 1/18

R2Uw-R'UR'U'RUw'-(R2x')-Uw'RUw

Mirror of n17

(y'U)D'R2U*R'UR'U'RU'R2-(DU')R'UR

French G. Only from this direction and AUF

 Permutation of Last Layer (PLL)
n1 (Ucw) n2 (Uccw) n3 (Accw) n4 (Acw)
R2U'R'
R'UR'U'- xR'UR'DDR
U'RU- xR2'DDRUR
R'U'- U'R'
RURU' ' DDRU'Rx'
R'URUR2 DDR2x'
R

n5 (Z) UR'U'RU' n6 (H) n7 (E) n8 (T)

x'RU'R'DRU RU*R'U'R'F
RU M2'UM
R'D' R2-
RU'R'U 2'U2M2
RUR'DRU'R' U'R'U'RUR'F
RU- 'UM2'
D'x '*
R2U'R'U
R'U'F'*
n9 (V) n10 (F) n11 (Ra) n12 (Rb)
RUR'- RU2'R'U2-
R'UR'Dw'- R'U2RU2'-
U'R'FR LwU'L'wU'-
R'F'R2U'R R'FRUR'U'-
2- RULwUL'wR
'UR'FRF R'F'R2U'
U'R'U'R 'U
UR'UR
n13 (Ja) n14 (Jb) R'U2'R n15 (Y) n16 (Ga)
R2U'R'U(R
RU2'R'U' UR'U2' RUR'y'-
U'x')z'-
RU2'- - R2Uw'RU'R'
L'U'RU'R'U'
L'UR'U'L LU'RUL U-R'UwR2
LU
'
R'U'R(
n17 (Gc) n18 (Gb) n19 (Gd) n20 (Nb)
R2'Uw'RU UD')R2 R2Uw-
R'UR'FRF'R
'RUR'- U*- R'UR'U'RU
U' R'F'UF-
UwR2FwR R'URU' w'-(R2x')-
RUR'U'R
'Fw' RU'R2' Uw'RUw
D(U')
n21 (Na)
U-LU'R-
U2'L'ULR' Shotaro Makisumi
cubefreak.net
U'RU2'L'U smakisumi at gmail
R'