Complete Rubik's Cube Notation Guide

Every algorithm you'll ever encounter in speedcubing is written in a standardized notation system. Understanding what each symbol means (from the basic face moves through slice moves, wide moves, and cube rotations) is the foundation of reading, memorizing, and discussing algorithms fluently.

Rubik's Cube notation was first formalized by David Singmaster in his 1980 book Notes on Rubik's 'Magic Cube', and has been refined and extended over the decades as competitive speedcubing developed. Today's notation system is internationally standardized, meaning an algorithm published in Japan reads identically in Brazil or Germany. Once you understand the system, every algorithm on every website and in every competition guide becomes readable.

Face Moves: R, L, U, D, F, B

The six basic face moves are the foundation of all Rubik's Cube notation. Each letter refers to a face of the cube, and executing the move means rotating that face 90 degrees clockwise when looking directly at it.

To use this notation correctly, you must first establish a consistent orientation. Hold the cube so that the white face is on the bottom (this is the standard CFOP starting position). In this orientation:

The most important thing to understand about face moves is that they are relative to your grip, not the cube's absolute orientation. If you rotate the entire cube so the green face is now facing you, then F now refers to green, not whatever color it was before. This is why cube rotations (covered in a later section) change what every face move means.

Modifiers: Prime and Double

A face letter by itself means 90 degrees clockwise. Two modifiers extend the system:

The prime symbol (') is sometimes written as an apostrophe, a superscript minus sign, or the letter "i" (for inverse) in older notation systems. All mean the same thing: reverse direction. When you see R' in an algorithm, execute the R move backward.

The number 2 always means two quarter-turns (a half-turn). Because a half-turn is the same going clockwise or counter-clockwise, direction doesn't matter for 2-moves, choose whichever is more ergonomic for the fingertrick. In practice, most cubers have a preferred direction for each double move based on their grip and the surrounding moves.

These six faces and two modifiers give you 18 possible moves (6 faces × 3 variants: normal, prime, double). These 18 moves are the complete vocabulary for most beginner and intermediate algorithms. The Sune, for example, is entirely composed of these basic moves:

Read this as: Right-clockwise, Up-clockwise, Right-counter-clockwise, Up-clockwise, Right-clockwise, Up-180-degrees, Right-counter-clockwise. Seven moves total. Practice reading it out loud until the symbol-to-action mapping is automatic.

Slice Moves: M, E, S

Slice moves rotate the middle layer of the cube, the layer that doesn't have a face of its own. There are three slice moves, one for each axis:

Slice moves are used less frequently than face moves, but they appear in specific algorithm families. The H-perm, a fully symmetric PLL case, is built almost entirely from slice moves and uses M2 (M double) repeatedly:

Some cubers use M moves in OLL algorithms and in F2L insertions where the middle-layer piece needs to move without affecting the surrounding edges. The key to executing slice moves quickly is developing a clean middle-layer finger technique, most advanced cubers use their index finger or thumb to drive M moves rather than turning the whole cube.

Wide Moves: Rw, Uw, Fw (or r, u, f)

Wide moves rotate two layers simultaneously, the face layer plus the adjacent middle slice. They are most commonly used in larger cube puzzles (4x4, 5x5) but also appear in some 3x3 algorithms, particularly for OLL and PLL execution.

The lowercase notation (r, u, f, etc.) is the older convention. The "w" suffix notation (Rw, Uw) is newer and more explicit. Both are widely used and mean exactly the same thing. Most modern algorithm databases use the "w" suffix, while older print resources often use lowercase.

On a standard 3x3 cube, Rw is equivalent to R plus M' (because turning the two right layers clockwise is the same as turning the right face clockwise and turning the middle layer in the direction opposite to L, which is M'). This relationship is useful when checking if two algorithm notations describe the same move sequence.

Cube Rotations: x, y, z

Cube rotations turn the entire cube without moving any pieces relative to each other. They change your grip orientation, which changes what every subsequent face move refers to. All cube rotations follow the same clockwise convention as face moves:

Cube rotations are not moves in the competitive sense; they don't change the solved/unsolved state of the puzzle. They change your relationship to the cube. A y rotation followed by an R move is equivalent to executing a B move from the original orientation.

In competition algorithms, cube rotations are often included explicitly when a cuber wants to describe an algorithm from a specific grip. For example, some OLL algorithms include a y rotation mid-algorithm to allow a more ergonomic finger sequence. When transcribing these algorithms, always include the rotation in the notation so others can reproduce the exact execution.

Move Count Metrics: HTM, STM, QTM

When comparing algorithms, move count matters, shorter algorithms (in terms of effective moves) are generally faster. But what counts as "one move" is not universally agreed upon, which is why several different counting systems exist:

Half Turn Metric (HTM)

HTM, also called "Face Turn Metric" (FTM), counts every quarter turn and half turn of a face as one move. R, R', and R2 each count as 1. Slice moves count as 1 each. Cube rotations (x, y, z) typically count as 0, since they don't change the cube's state. HTM is the metric used to define God's Number: the maximum number of HTM moves needed to solve any cube position is 20.

Slice Turn Metric (STM)

STM counts every distinct turn, face turns and slice turns, as one move. It is similar to HTM but explicitly includes M, E, and S moves. Some wide moves are counted as two in HTM (since Rw = R + M') but as one in STM, making STM give lower counts for algorithms that use wide moves.

Quarter Turn Metric (QTM)

QTM counts every quarter turn as one move, but double moves (R2, U2, etc.) count as two. This metric is used in some theoretical analysis of optimal algorithms but is rarely referenced in practical speedcubing. An algorithm that is efficient in HTM may be less efficient in QTM if it contains many double moves.

For practical speedcubing, HTM is the most commonly cited metric. When a guide says "this OLL algorithm is 8 moves," it almost always means 8 HTM. At advanced levels, cubers optimize for both move count and ergonomics simultaneously; the fastest algorithm to execute is often not the shortest in HTM because finger trick efficiency matters more than raw count.

How to Read a Full Algorithm

Algorithms are always read left to right, executing each move in sequence. Parentheses and brackets sometimes appear in written algorithms for grouping and readability, they do not change the execution order. The notation [R U R' U'] means the same as R U R' U'; the brackets just visually group what cubers call the "sexy move" trigger.

Let's read a complete OLL algorithm step by step. This is the algorithm for OLL 37 (Fish shape, right):

• F. Rotate the front face 90° clockwise
• R. Rotate the right face 90° clockwise
• U. Rotate the top face 90° clockwise
• R'. Rotate the right face 90° counter-clockwise
• U'. Rotate the top face 90° counter-clockwise
• F'. Rotate the front face 90° counter-clockwise

Six moves. You'll notice this algorithm is symmetric: it starts with F and ends with F', and the middle is an R U R' U' trigger sandwiched between the two F moves. Many algorithms have this internal structure, which is why experienced cubers can often reconstruct algorithms from a visual memory of their shape rather than memorizing each individual move.

Now a more complex example, the A-perm PLL:

This 9-move algorithm contains a mix of face moves, primes, and a double move. Read it through letter by letter: R', F, R', B2 (back 180°), R, F', R', B2, R2. When executing this in practice, cubers often grip the cube so that the B moves fall naturally on the left hand, making the alternating R-B-R-B pattern smooth and fast.

Notation Variations You'll Encounter

While modern notation is highly standardized, you'll encounter some historical and regional variations when reading older guides or non-English resources:

• Lowercase letters for face moves: Some European guides use lowercase r, l, u, d, f, b for face moves, not wide moves. Context usually makes it clear. If a notation source is older than 2010, lowercase likely means a face move, not a wide move.
• "i" for prime: Older notation uses Ri, Ui, etc. instead of R', U'. Same meaning.
• "2" vs "²": Both mean half-turn. The superscript 2 is typographically nicer but functionally identical.
• Underscores for finger tricks: Some community resources annotate efficient finger tricks using subscripts or underlines. These are performance notes, not part of the algorithm itself.
• Spaces and parentheses: Algorithm formatting varies by author. Some write R U R' U' with spaces, others without. Some group triggers in parentheses. Execution is identical.

When you encounter unfamiliar notation, the safest approach is to look for a notation key on the same page or website. Most modern speedcubing resources follow the Singmaster notation described in this guide, with the wide-move convention being the main area of variation.

Practice: Decode These Algorithms

The best way to internalize notation is to decode algorithms slowly and then execute them. Try these three:

Beginner: The Sexy Move

Four moves. R clockwise, U clockwise, R counter-clockwise, U counter-clockwise. This is called the "sexy move" by the community and appears as a sub-unit inside dozens of OLL and F2L algorithms. Learn it so well that you can execute it in one fluid motion.

Intermediate: Sune (OLL 27)

Seven moves. Note the U2 at the end, the top face rotates 180° before the final R'. The Anti-Sune (OLL 26) is the mirror: R' U' R U' R' U2 R. Learning to see mirror algorithms as inverses of each other cuts your memorization load in half.

Advanced: T-Perm (PLL)

Fourteen moves, including an F and F' that bookend a core sequence. This is one of the most common PLL cases. Notice the sub-units inside it: R U R' U' is the sexy move at the start, and R' F R2 ... R' F' is a conjugated version of a longer trigger. Breaking long algorithms into familiar sub-units is the fastest way to memorize them.

Related reading: CFOP for Beginners · Top 10 OLL Cases · Speedcubing Glossary