Learning Standard F2L
This pages teaches mostly intuitive F2L, explaining the "algorithms" when possible. In particular, only one directon (target slot FR) is given for each algorithm. Each is written in my style through 2008, making ample use of double layer turns and rotations. You may also consider learning F2L with even more emphasis on intuition; see for example Doug Reed's guide. Cubers who already know F2L should look at the F2L list, which shows my recommended algorithm for standard cases from all directions. A much more complete list can be found on Advanced F2L.
Menu
4 Basic Patterns
Corner and edge on U, corner points to side (except K)
Corner and edge on U, corner points up (and K)
Corner in place, Edge on U
Corner on U, Edge in place
Corner and edge in place
4 Basic Patterns
Almost all basic F2L algorithms can be broken down into two stages: 1) place the corneredge pair in one of the following four basic patterns; 2) solve the basic pattern. It is therefore essential that you first learn to recognize the following four cases.
Code  Pattern  Algorithm 
I1 

Dw'L'UL 
T1 

RUR' 

Code  Pattern  Algorithm 
I2 

URU'R' 
T2 

y'R'U'R yL'U'L 

Whenever an algorithm follows this twostep pattern, the only part we need to memorize is the first step, which usually takes only 3 or 4 moves. In all these algorithms below, I have italicized the first step. Of course, we eventually need to know the second step to speed up, but this easily comes with practice.
Corner and edge on U, corner points to side (except K)
For the purpose of this page, a firstlayer corner "points" in the direction of its firstlayer sticker. Since I use blue as the cross color, a corner pointing to the side would mean, for me, that the blue corner sticker is on one of the side faces.
Most of these cases have the twostep pattern described above and follow the following simple rules:
Define the "target edge" to be the position relative to the corner where the edge can be placed, without being flipped, to create one of the basic patterns. This means that, if the corner and the edge have the same color on top, we reduce to I1 or I2. If they are different, we reduce to T1 or T2.
The first two moves are always either U'R or UF' (using double layer, DwR'), both of which brings the corner to the bottom two layers. In most cases, one or the other leaves both the edge and the target edge on U. Apply this one.
Now turn the U layer until the edge is where the target edge was. When you bring back the corner to U, the corneredge pair should be in a basic pattern.
For example, in Q1, the corner and the edge have the same color on top, so we reduce to I, which means that the target edge is UF in the position shown. DwR' is therefore the correct opening, U' moves the edge to the target, and R brings back the corner, completing the first step. These solutions should all feel obvious after some practice.
Code  Pattern  Algorithm 
Q1 

DwR'U'RDw2'L'UL 
S1 

DwR'U2RDw2'L'UL 
J1 

DwR'U2RDw'RUR' 
L1 

U'RU'R'URUR' 
R1 

U'RUR'URUR' 

Code  Pattern  Algorithm 
Q2 

U'RUR'U2RU'R' 
S2 

U'RU2'R'U2RU'R' 
J2 

U'RU2R'DwR'U'R 
L2 

DwR'URU'R'U'R yUL'ULU'L'U'L 
R2 

U'RU'R'DwR'U'R URUR'UDwR'U'R 

Note that, for R1 and R2, both U'R and DwR' keep both the edge and the target edge on U. We choose the opening that allows for more finger tricks or has less cube rotations.
For K1 and K2, neither opening keeps both the edge and the target edge on U. We group this together with the second group.
Corner and edge on U, corner points up (and K)
We now hold the edge in the first two layers and keep the corner on U. For U and V, the edge is aligned with the first two layers, hidden in the first two layers, and the pair is reduced to I. The alternate algorithms provided for V1 and V2, which are sometimes useful from different angles, do not follow this pattern.
Code  Pattern  Algorithm 
K1 

RU'R'U'Dw'L'U'L 
N2 

RU2'R'U'RUR' 
U1 

Dw'L'U2LU'L'UL 
V1 

U2'RUR'URU'R' RU'R'U2RUR' 

Code  Pattern  Algorithm 
K2 

y'R'URU'Dw'RUR' 
N1 

y'R'U2'RUR'U'R 
U2 

URU2'R'URU'R' 
V2 

UDwR'U'RU'R'UR yL'ULU2'L'U'L U2'RUR'y'R'U'R 

Note the similarity in the first steps of K1 and N2 and of K2 and N1.
The last case, M, can be reduced to I or T. However, the optimal solution (first line) does not follow the twostep pattern. This is one of the few F2L sequences with no intuitive explanation. Sorry.
Code  Pattern  Algorithm 
M1 

U2'R2U2'R'U'RU'R2' RUR'U2RUR'U'RUR' RU'R'U'RUR'U2RUR' 

Code  Pattern  Algorithm 
M2 

yU2'L2U2LUL'UL2 U'R'FRF'U'F'U'F 

Corner in place, Edge on U
Code  Pattern  Algorithm 
A1 

URU'R'Dw'L'UL 
E1 

yL'ULU'L'UL RU2'R'F'U2F 
F1 

U'RUR'U'RUR' 

Code  Pattern  Algorithm 
A2 

Dw'L'ULDwRU'R' U'R'FRF'RUR' 
E2 

RU'R'URU'R' 
F2 

yUL'U'LUL'U'L UR'FRF'URU' 

Corner on U, Edge in place
G and H differ in the first step only in the direction of the second quarter turn U. G is reduced to I, and H is reduced to T. B can be reduced to either and can be used to control the edge orientation of the last layer.
Code  Pattern  Algorithm 
B1 

(URU'R')x3 (RUR'U')x3 y'(RB'R'B)x3 
G1 

URUR'U2'RUR' U'RU2'R'URUR' yUL'ULU2'L'UL 
H1 

yUL'U'LU'y'RUR' yzRU'R'UR'FRF' 

Code  Pattern  Algorithm 
B2 

U'R'FRF'RU'R' RU'R'F'U2F 
G2 

U'RU'R'U2RU'R' 
H2 

U'RUR'DwR'U'R 

Corner and edge in place
The optimal sequences for all cases here are difficult to understand intuitively. C1 and C2 can be reduced to U2 and N2 by RUR' and RU'R', respectively. The first three moves of the first algorithm for A0 reduces the case to J2. The second can be used for last layer edge control.
Code  Pattern  Algorithm 
C1 

yL2U2LUL'ULU2L 
D1 

y'R'UR'U'F'UFR2' 
A0 

RU2'R'URU2'R'DwR'U'R RUR'FUDwR2U'R2'Dw'R'F'R 

Code  Pattern  Algorithm 
C2 

R2U2'R'U'RU'R'U2R' 
D2 

RU'RUy'LU'L'B2'
Or reduce to another case (e.g. RU'R'U'RU'R'DwR'UR) 
