Every cube algorithm is written in the same alphabet. It fits in about a dozen letters, and once you read it without thinking, learning an algorithm becomes a job for your fingers instead of a decoding exercise. This page covers all of it. In the app, the moves lexicon (the “Moves” button in the header) shows each one animated on the virtual cube.

The six faces

Each letter names a face of the cube as you see it while holding it: notation never talks about colours, only positions. If you turn the cube in your hands, the letters follow the cube, not the colours.

Letter Face How to remember it
U Up, the top the one you look down on
D Down, the bottom the one resting on your palm
F Front the one looking at you
B Back the one you can’t see
R Right on your right-hand side
L Left on your left-hand side
Seen from the front
Seen from behind and below

The six faces, with the cube held in front of you. On the left, the ones you can see: top, front, right. On the right, the other three, with the cube seen from below and behind.

A letter on its own, like R, means: a quarter turn clockwise, looking straight at that face. This is where everyone goes wrong at first with B, L and D: “clockwise” is judged from the face itself, not from where you are. For L, imagine turning the cube so the left face is right in front of your eyes, then turn it like a clock. The result: seen from the front, L goes down when R goes up.

R
U
F
L
B
D

The clockwise quarter turn of each face, with the arrow seen from that face. For L, B and D, the cube is shown from their side: that is where "clockwise" is judged from.

Modifiers

  • An apostrophe (R', read “R prime”) reverses the direction: a counter-clockwise quarter turn.
  • A 2 (R2) is a half turn, in whichever direction you like, since the result is the same.
R
R'
R2

The three ways to turn a face: a clockwise quarter turn, a counter-clockwise quarter turn, a half turn.

That’s all there is. So R U R' U' reads: right clockwise, top clockwise, right counter-clockwise, top counter-clockwise. This four-move sequence is called the sexy move, and you’ll find it in a good share of OLL algorithms.

Start
R
U
R'
U'

The sexy move one move at a time, from a solved cube. Six repetitions bring the cube back to where it started.

Two layers at once, middle slices

Advanced algorithms use a few more letters.

  • Lowercase: r, l, u, d, f, b turn two layers together, the face and the slice next to it. r moves the right face and the middle slice in the same direction as R. Some sites write Rw (wide) for the same thing.
  • Middle slices: M (between L and R), E (between U and D), S (between F and B). Watch the directions: M follows L, E follows D, S follows F. In practice you’ll mostly meet M and M'; the edge PLLs (Ua, Ub, H, Z) use nothing else.
after R
after r
after M
after M'

From a solved cube: R turns only the right face, r drags the middle slice along too, M turns only the slice, in the direction of L (the front column goes down), and M' brings it up.

To remember which way M goes: M' pushes the middle column up and towards the back, as if your right middle finger were pushing a lift up from underneath. It is by far the most common slice move, and you do it with a finger, not by turning your hand.

Whole-cube rotations

x, y and z turn the whole cube without scrambling anything: they are changes of grip.

  • x turns the cube like R: the front goes to the top.
  • y turns the cube like U: the right goes to the front.
  • z turns the cube like F: the left goes to the top.
after x
after y
after z

The cube after each rotation, starting from a solved cube held yellow on top and green in front. Nothing gets scrambled: only the centres, and so the letters, move.

They take ' and 2 as well. When an algorithm starts with x or y, do that rotation first: the letters after it are read in the new grip. Several corner PLLs work this way, for example Aa: x R' U R' D2 R U' R' D2 R2 x'.

Holding the cube during an algorithm

An algorithm only works if you run it in the orientation it was written for. In the app, each case starts with an instruction (“turn U until…”): that is the case’s canonical orientation, the one where the algorithm applies exactly as written.

Good habits:

  1. Yellow centre on top, white centre at the bottom for everything after the cross. The colours at the front and on the right change from one case to the next; the case instruction tells you which.
  2. Don’t change your grip in the middle of an algorithm, unless it contains an x, y or z rotation. If your hands reposition the cube to reach B, everything after that goes wrong.
  3. Read in chunks, not letter by letter: R U R' U', R' F R F' and F R U R' U' F' are blocks that turn up everywhere. The page How to learn an algorithm explains how to use them.

Classic mistakes

  • L and B the wrong way round: clockwise is judged from the face, see above. Until it’s automatic, check by bringing the face round to the front.
  • Mixing up R and r: the lowercase letter drags the middle slice along. An algorithm that ends with a centre out of place almost always has an r read as an R, or the other way round.
  • Forgetting the prime on the last move: people read the end of an algorithm too fast. The app’s virtual cube replays the algorithm one move at a time (left and right arrows): compare its last move with what you do.
  • Doing U2 in a direction that gets in the way of the next move: both directions are correct, but one of them flows better into the next move. Try both and keep the smoother one.

Once you know the alphabet, the real work begins: remembering algorithms without reading them. That’s the subject of the next page.