1

F (R U R' U') F'

Simplest OLL of them all

F (R U R' U') (R U
R' U') F'

Just repeat the trigger one more time

F (R U R' U') (R U
R' U') (R U R' U')
F'
y (R' U' R) U' (R' U
R) U' (R' U2 R)

Just repeat the trigger 3 times. The second one is the one I use, its
much faster

f (R U R' U') f'

Instead of F F' you now have f and f '

f (R U R' U') (R U
R' U') f'

Just repeat the RUR'U' trigger 2 times

f ' (L' U' L U) f

This is the reflection of P. You are just doing the algorithm with your left
hand. It should be quiet easy to transfer it with just a little bit of practice.
I execute it more like f' L' U' L U y' r

F' (L' U' L U) (L' U'

L U) F

This is reflection of Case 2. Just do the trigger twice.

[F (R U R' U') F'] U

[F (R U R' U') F' ]

This is just T, twice, with a U in between.

[F' (L' U' L U) F] y

[F (R U R' U') F']
y (r U R' U)(R' F R
F') R U2 r'

Reflection of case 1 followed by case 1, with a y rotation in between,

and it comes very natural in that position I find.
Second algorithm was suggested to me and I kinda like it.

10

[f (R U R' U') f'] U

[F (R U R' U') F' ]

This is just case4 followed by case 1, with a U in between

11

[f (R U R' U') f'] U'

[F (R U R' U') F' ]

This is case 10 with a U' instead of U

12

[F (R U R' U') F' ]

[f (R U R' U') f']

This is T (case 1) followed by P (case 4)

13

[f (R U R' U') f'] [F

(R U R' U') F']
R U2' R2' U' R2 U'
R2' U2 R

This is just like the above, but T (case1) and P (case 4) are done in
reverse order!
You should really learn the second algorithm though, its much faster. Its
the one everyone fast uses too.

14

(r U r') (R U R' U')

(r U' r')

This algorithm is very easy to remember

15

(l' U' l) (L' U' L U)

(l' U l)

Reflection of case 14

16

R' [F (R U R' U')

F'] U R

Look how neatly case 1 (T) is placed in middle there :)

17

(R U R' U') M' (U R

U' r')

I find this one pretty easy to remember too and it flows very nicely. It
doesn't come up too often though

18

M U (R U R' U')
M2 (U R U' r')

This almost never comes up, so skip it if you want. But its not too bad.
Note the last part is the same as in case 17.

19

F (R U R' U') R F'

(r U R' U') r'

The second trigger in brackets is almost the RUR'U' trigger

Second: Learn another trigger, (R' F R F')

Case

Diagram

Algorithm

Comment

20

(R U R' U') (R' F R F')

Just the two triggers is all it takes :)

21

(r U R' U') (r' F R F')

Same as T2 (case 20) but the first R's are

actually double layer R turn (r)

22

F' (r U R' U') (r' F R )

Same as chameleon (case21) , with the last

F' moved to the front!

23

R' U' (R' F R F') U R

There are some setup moves involved here.

Note how U R "undoes" the R' U' you do in
beginning

24

(R U2 R') (R' F R F') U2 (R' F R F')

The R' R' is obviously made as a giant R2 in

the actual execution

25

(R U2 R') (R' F R F') (R U2 R')

Incredibly easy to remember, and fast to

execute. Again, the R' R' is made as a big
R2. Note first part is the same as in case 24

26

M U (R U R' U') M' (R' F R F')

pretty easy to remember. Also note how

similar this algorithm is to case 17

27

(R' F R' F') R2 U2 y (R' F R F')

Be warned that the first trigger is not really

R'FRF' trigger. But almost... the second R
turn in it is R', not R

You now know almost half of the OLL's!

Third: A very similar trigger to the first trigger. It is (R U R' U). Only difference is that the last move
is a U not a U'
Case

Diagram

Algorithm

Comment

28

(R U R' U) (R U' R' U') (R' F R F')

Very quick to perform. Second part is

same as first, but with U's instead of Us

29

(L' U' L U') (L' U L U) (L F' L' F)

The reflection. Should be easy enough

to mirror it.

30

(R U R' U) R d' R U' R' F'

(R' U' R U') R' d R' U R B

I use the first one, but both are very

good, and its definitely a judgement
call per individual

31

(R U R' U) (R' F R F') U2 (R' F R F')

Easy to remember. Note similarity to

case 24.

32

[F (R U R' U) F'] y' U2 (R' F R F')

Easy. This is ALMOST case #1, but

with that modified trigger. I execute this
by doing y' R' U2 instead of the F' y'
U2. But thats a detail.

33

r' U2 (R U R' U) r

Easy.

34

(r U R' U) R U2 r'

slight variation of the trigger and then

easy finish

Fourth: Sune and its derivatives

Case

Diagram

Algorithm

Comment

35

(R U R' U) R U2 R'

Very quick OLL. Look what

happens to one of the F2L pairs as
you execute it.
The whole algorithm is just: Take
out a pair, move it over, insert it
back. It's also very similar to case
34

36

R U2 R' U' R U' R'

This algorithm is the same as case

35 in philosophy. Track the F2L
pair.

37

[ R' U2 (R U R' U) R] y [F (R U R' U') F']

(R' F R F') (R' F R F') (R U R' U') (R U R')

First part is just the sune from

different angle (similar to case 33),
and second part is the T OLL.
The second algorithm was
suggested to me by someone, and I
kinda like it even more! To do the
R'FRF' parts, I actually make a
cube rotation x and then execute
them as R'URU'.

38

[(R U R' U) R U2 R'] [F (R U R' U') F']

This is basically the Sune followed

by the T(case 1)

Algs that you just learn because they are incredibly fast, but don't really fit with what I've been doing
above. There is 18 more of those
Case

Diagram

Algorithm

Comment

39

(r U R' U) (R U' R' U) R U2' r'

Incredibly
quick to
execute. I
love this
algorithm.
When you
execute it, it
feels like the
two fingers
on right and
left hand are
in battle,
flicking
towards
each other
the top layer
like crazy :)

40

l' U' L U' L' U L U' L' U2 l

y2 r' U' R U' R' U R U' R' U2 r

I execute
one or the
other
depending
on which
angle I run
into the OLL
in. It saves
me a y2
rotation.
First one is
just
reflection of
case 39.

41

r U2 R' U' R U' r'

quick alg.
Note how
similar it is
to 36! Just
replace R>r.
Uncanny!

42

F R U' R' U' R U R' F'

very quick.
Note the Y
permutation
starts with
this exactly

43

r' U' R U' R' U2 r

quick, and
very similar
to sunes
(cases 3438)

44

M' U M U2 M' U M

easy. Look
what
happens to
one of the
cross
edges. You
take it out,
do a U2,
and put it
back from
the other
side.

45

(R U R2 U') (R' F) (R U) (R U') F'

(R U R' U') x D' R' U R U' D x'

I cannot
decide
which one is
better... you
have to pick
for yourself

46

F U R U' R2 F' R (U R U' R')

note how
the last part
just inserts
an F2L pair
back.

47

R' F R U R' F' R y' (R U' R')

pretty nice
alg. Last
part just
inserts F2L
pair

48

R2 [D (R' U2) R] [D' (R' U2) R']

I don't like
this alg too
much. Note
the
repeating
structure.

49

R' U2 R2 U R' U R U2 x' U' R' U

... i don't like

this one too
much

50

R U B' U' R' U R B R'

R d L' d' R' U R B R'

The B' is
very
clumsily
done. Try do
it with your
thumb, then
the rest is
very quick. I
use the
second
algorithm,
but I'm not
sure which
one is better

51

R' U' F U R U' R' F' R

y2 L' d' R d L U' L' B' L

I use the
second one,
but I think
the first may
be a little
better.

52

R B' R' U' R U B U' R'

y2 L F' (L' U' L U) F U' L'

Try to use
the thumb
for the B'
too, i think.
Pretty
clumsy as
well, but
after it its
quick

53

R' F R2 B' R2' F' R2 B R'

Again, I do
the B' with
my thumb.
Awkward
alg. ew.

54

(R U R' U') R U' R' F' U' F (R U R')

[F (R U R' U') F'] U2 [(R U R' U') (R' F R F')]

flows nicely,
no regrips.
The second
one is
longer but
easier to
remember:
It is just
case 1
followed by
U2 and case
20!

55

(R2 U R' B' R) U' (R2 U R B R')

Ok the first
R2 is
executed in
a weird way.
You overgrip
the R slice
to do the R2
both times.
After doing
the R2's you
have to be
able to the
U with a
finger flick
without a
regrip. The
alg is
actually
quite fast.

56

(R' U' R) y' x' (R U') (R' F) (R U R')

(R U R' U') R' F R2 U R' U' F'

after the
ugly y'x' the
alg is
incredibly
fast. I love
executing
that part. I
give a
second
alternative
in case
someone
wants
something
else
because
they dont
like the
rotation.
(Note that
the second
alg looks
very much
like the T
PLL :) )

57

R U R' y R' F R U' R' F' R

(R U R' U) (R' F R F') R U2 R'

I try to use
the first one.
The second
one was
suggested
to me and
its incredibly
easy to
memorize,
but I don't
think its AS
fast as say
the first one.

Plls
x [(R' U R') D2] [(R U' R') D2] R2

A (a)
1/18
XXXThe algorithm has a little bit of a symmetry to it. I have a very weird way to memorize this
algorithm tracking the two corners in UBR and UFR around the cube as I do it. But I know that

many of my friends do it differently. Find what suits you best, it is not too hard or long.

x' [(R U' R) D2] [(R' U R) D2] R2

A (b)
1/18
XXThis is the exact same type of motion you do in A(a). If you memorized it by motions instead

of notation, you should be able to do this one without too many problems.

[R

U'] [R U] [R U] [R U'] R' U' R2

U (b)
1/18
XNote how the algorithm is basically always R and then U' U U U' in that symmetrical order

accompanying the R, and lastly R' and fix up rest by aligning pieces.

R2 U [R

U R' U'] (R' U') (R' U R')

U (a)
1/18
XThe way I remember it: R2 U, then the RUR'U' trigger, then the last two letters of the RUR'U'
trigger, then do R' and fix up rest by aligning pieces and putting them to their right positions.

M2 U M2 U2 M2 U M2

H
1/72

XA very easy to remember algorithm. Note how the M2's always alternate, and in between you

simply have just U, U2, U

[R U R' U'] [R' F] [R2 U' R'] U' [R U R' F']

T
1/18
XXI find it easy to learn this algorithm by tracking F2L pairs around the cube.RUR'U' takes out a
pair. R'F hides it and takes the other pair out to the top layer. R2U'R' aligns this pair with the
whites and hides that pair. Now all the pairs are hidden from the top layer. Now we do U' on the
Top Layer. Finally RUR'F' takes the second pair out and aligns it with the whites again, and

restores the First Two Layers.

[R U R' F'] {[R U R' U'] [R' F] [R2 U' R'] U'}

J (b)
1/18
XNotice that this is EXACTLY the same algorithm as the one above but the RUR'F' from the end
was now moved to the beginning! So just do RUR'F' and then start doing the T permutation

(above) until you see that the cube is solved!

F R U' R' U' [R U R' F'] {[R U R' U'] [R'

F R F']}

Y
1/18
XXAgain I find it helpful to see how F2L pairs move around for this algorithm. F brings an F2L
pair to the top, RU'R' inserts that pair back to the middle. Now again as before, all F2L is again
intact, but slightly messed up. Then U' is done as in T permutation, and then RUR'F' is AGAIN
used to take that pair and insert it back where it was before. The result will leave you with an
OLL, which after when you fix using the appropritate algorithm, you will be left with Ypermutation
at the end. Note that the OLL is very easy: It takes one pair out to top layer, and inserts it back a

different way (in particular, using R'FRF')

[R' U2 R U2] [R' F] [R U R' U'] [R' F'] R2 U'

R (b)
1/18
XXAgain for this one I find it easiest to track an F2L pair. Remember the first part using just
notation because it is easy. After R'F you have an F2L pair on the bottom. Then you do RUR'U'
trigger. Next, R'F' reconnects that F2L pair and alligns it with the whites on top, and R2U' just

finishes it all up.

[L U2' L' U2'] [L F'] [L' U' L U] [L F] L2' U

y2 [R U2 R' U2] [R B'] [R' U' R U] [R B] R2 U

R (a)
1/18
XThis is just the reflection of the above. You need to do the above, but using the left hand
instead of the right hand. You will be able to mirror the R permutation to your left hand after
about a weeks practice of doing it with your right hand. When it becomes a little bit of muscle
memory for you it should be really easy to mirror the algorithm with the left hand. So if you can't
do it right away, just wait a little more and get a little more comfortable with R(b). The second
algorithm is an alternative that I sometime like to do because it involves the (faster) right hand

instead.

[R' U R' d'] [R' F'] [R2 U' R' U] [R' F R F]

V
1/18
XXXXI don't really have a great way to memorize this and thats why I rated this as a hard
algorithm. I kind of just did it until I had it in my muscle memory. Note how the R'FRF at the end

is ALMOST the common R'FRF' trigger, but with F instead of F' at the end.

[R' U2

R' d'] [R' F'] [R2 U' R' U] [R' F R U' F]

F
1/18
X
If you know V permutation, this one is REALLY easy. I highlighted the differences. There is
simply one extra U, so instead of R' U R' in the beginning you have R' U U R' (or R' U2 R'), and

then you have to undo that U at the end of the algorithm, so there is an extra U' that pops in
from nowhere near the end of the algorithm.

[R U R'] y' R2 u' R U' R' U R' u R2

G (d)
1/18
XXRUR' takes out a pair. Then rotate the cube, and now the fun part starts. I highleted the R
rotations so that you can see the pattern better. Notice in particular how the U turns are. It is u'
U' U u. It has a very nice symmetry to it. The R's I remember as follows: Since in execution I
perfrom the R2 as RR (in clockwise motion), I see them as R clockwise twice, and then R
counterclockwise twice, and the final R2 is just to finish up the algorithm. You are welcome to
come up with better memory techniques for this things. I know a couple of friends, each with

different ways of remembering these G perms...

[R' U' R] y R2 u R' U R U' R u' R2
G (b)
1/18
XXThis is similar. First take out the pair that is right under the aligned 2x1x1 block, as in G(d),
and then rotate the cube, and do a similar pattern. See how there is a symmetry to the U's
again? u U U' u'. When I execute, I do the first R2 as R' R', counterclockwise motion. So I think

CCW, CCW, CW, CW, and final R2 just to fix it all up.

R2 u' R U' R U R' u R2 [y R U'

R']

G (c)
1/18
XXXThis is simply G(d) inverted. But I find it useless to remember it like that. This is like a
completely new algorithm for me. Note the still distinct pattern to the U's. And also R's.
Remember it as you wish. The last part yRU'R' just inserts an F2L pair once the first part is

done.

R2 u R' U R' U' R u' R2 [y' R' U R]

G (a)
1/18

XXThis is very similar to G(c). Everything just goes the other way :)
M2 U M2 U M' U2 M2 U2 M' U2

Z
1/36
X
Similar to the H permutation, I find this easy to remember, and I saw some people executing it

extremely quickly.

[R' U L'] [U2 R U' R' U2] [R L U']

J (a)
1/18
XX1st part is exactly as in N(b), below. But then you do U2RU'R'U2 which I find personally very
easy to remember. The last part (RLU)just simply restores all yellows and I find it very easy to

see it visually.

x' (R U' R') D (R U R') D' (R U R') D (R U' R') D'

x (R U' R') D (R U R') u2 (R' U R) D (R' U' R)

E
1/36
XXThis algorithm has a nice symmetry to it, as highlighted. Some people fund the second one

faster to execute

{(R' U L') U2 (R U' L)} {(R' U L') U2 (R U' L)} U'

N (b)
1/72
XNote how the algorithm is made up of two IDENTICAL pieces (in squigly brackets).

To memorize this, track the corner in UBR. As you do R'UL', it will travel along a U on the top
layer of the cube. Then do U2, and then restore yellows by doing RU'L. Then repeat that whole
thing again.

I hate executing this algorithm. Its a good thing that it rarely ever comes up.
{(L U' R) U2 (L' U R')} {(L U' R) U2 (L' U R')} U

N (a)
1/72
XThis is just the mirror of the algorithm above and should not be hard to learn.