First Two Layers (F2L)

Printable F2L PDF in American color scheme (cross color white).

Identical page with less applets (Japanese color scheme, cross color white)

After cross comes the F2L (First Two Layers), arguably the most important step of Fridrich Method. This step completes the first two layers by fixing the four corner-edge pairs (slots) between the cross edges in four steps, one slot at a time. There are 41 basic "algorithms" to insert a corner and its corresponding edge into their correct spot in the correct orientation. However, most of these are short and intuitive compared to the last layer algorithms.

Because the four pairs can be solved in any order, F2L is a relatively flexive step and allows for many time-saving techniques. First take a look at Getting Fast with an Easy Method for such techniques in the simpler setting of layer-by-layer. Also, rather than blindly applying the algorithms, it is important to understand how each one works. Consider learning the F2L intuitively first from Doug Reed's guide and then comparing your algorithms with my list or with those at cubeloop.com.

This page first lists the 41 standard F2L cases with target slot FR. Each is written as I would perform it, making ample use of double layer and whole cube turns. Where appropriate, I have provided multiple algorithms. While one per case will suffice, one algorithm is often better than the other from a certain angle. The rest of the page explains some techniques that require no extra algorithm. To really master F2L, I recommend that you work on these techniques at the same time as you learn the algorithms.

More advanced techniques, requiring new algorithms, are covered in Advanced F2L.

Here are some F2L guides that people have found useful:
badmephisto's guides: F2L Part 1/2, F2L Part 2/2

Menu

Cross Placement
41 Standard F2L Cases
Wrong Slot
Different Angle or Target Slot
Empty Slot
Mismatched Pair
Looking Ahead and Simple Multislotting
Sample F2Ls

Cross Placement

This page lists the F2L "algorithms" with the cross on bottom. Most top speedcubers place the cross on D or L during F2L (or on R if left-handed). Although more cubers use D-cross because this is how F2L was popularized, both placements should be equally good. Personally, I mostly solve with D-cross but switch to L-cross (or just tilt in the z-direction) for a few slots depending on the F2L case.

Avoid placing the cross on top. This gives you very little view of the last layer, which contains the pieces you want to move.

41 Standard F2L Cases

4 basic patterns

Almost all basic F2L algorithms can be broken down into two stages: 1) place the corner-edge 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.

CodePatternAlgorithm
I1 Dw'L'UL
T1 RUR'
CodePatternAlgorithm
I2 URU'R'
T2 y'R'U'R
yL'U'L

Whenever an algorithm follows this two-step 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 first-layer corner "points" in the direction of its first-layer 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 two-step 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 corner-edge 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.

    CodePatternAlgorithm
    Q1 DwR'U'R-Dw2'L'UL
    S1 DwR'U2R-Dw2'L'UL
    J1 DwR'U2R-Dw'RUR'
    L1 U'RU'R'-URUR'
    R1 U'RUR'-URUR'
    CodePatternAlgorithm
    Q2 U'RUR'-U2RU'R'
    S2 U'RU2'R'-U2RU'R'
    J2 U'RU2R'-DwR'U'R
    L2 DwR'UR-U'R'U'R
    yUL'UL-U'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.

    CodePatternAlgorithm
    K1 RU'R'-U'Dw'L'U'L
    N2 RU2'R'-U'RUR'
    U1 Dw'L'U2L-U'L'UL
    V1 U2'RUR'-URU'R'
    RU'R'-U2RUR'
    CodePatternAlgorithm
    K2 y'R'UR-U'Dw'RUR'
    N1 y'R'U2'R-UR'U'R
    U2 URU2'R'-URU'R'
    V2 UDwR'U'R-U'R'UR
    yL'UL-U2'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 two-step pattern. This is one of the few F2L sequences with no intuitive explanation. Sorry.

    CodePatternAlgorithm
    M1 U2'R2U2'R'U'RU'R2'
    RUR'U2RUR'U'RUR'
    RU'R'U'RUR'U2RUR'
    CodePatternAlgorithm
    M2 yU2'L2U2LUL'UL2
    U'R'FRF'-U'F'U'F

    Corner in place, Edge on U

    CodePatternAlgorithm
    A1 URU'R'-Dw'L'UL
    E1 yL'UL-U'L'UL
    RU2'R'-F'U2F
    F1 U'RUR'-U'RUR'
    CodePatternAlgorithm
    A2 Dw'L'UL-DwRU'R'
    U'R'FRF'-RUR'
    E2 RU'R'-URU'R'
    F2 yUL'U'L-UL'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.

    CodePatternAlgorithm
    B1 (URU'R')x3
    (RUR'U')x3
    y'(RB'R'B)x3
    G1 URUR'-U2'RUR'
    U'RU2'R'-URUR'
    yUL'UL-U2'L'UL
    H1 yUL'U'L-U'y'RUR'
    yzRU'R'U-R'FRF'
    CodePatternAlgorithm
    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.

    CodePatternAlgorithm
    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
    CodePatternAlgorithm
    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)

    Corner or Edge (but not both) in a wrong slot

    It happens very often in F2L that none of the standard cases seemingly applies. The following technique allows us to use one of the algorithms above even when a corner or an edge is in the first two layers as long as the other piece in the pair is on top.

    This is actually almost the standard case. Since every case among the 41 standard cases that has either a corner or edge in place has the two-step structure discussed earlier, their equivalents with corner or edge in wrong slot can be solved without any additional algorithm. Pretend that the wrong slot containing a corner or an edge is in fact the target slot, and perform step 1 (the italicized part) for the appropriate case. Since this brings the corner-edge pair onto U and in one of the four standard cases, the pair can easily be inserted into the correct slot after adjusting by appropriate numbers of U and Dw.

    The following examples demonstrate this. Use the second arrow from the right on the applet to see each solution one move at a time.

    Example 1

    Note that, although the corner is in a wrong slot, otherwise this is the standard case E2: RU'R'-URU'R'. First do step 1 of E2, RU'R', to pair the corner and the edge. Now Dw2 brings the target slot to FR and leaves us with a basic pattern, URU'R'.

    Full solution: RU'R'-Dw2-URU'R'.
    Example 2

    We recognize this as H2: U'RUR'-DwR'U'R, so start with U'RUR'. Dw2 then brings the target slot to FR, leaving us with a basic pattern, UF'U'F.

    Full solution: U'RUR'-UDw2-F'U'F.

    Different Angle or Target Slot

    Using the technique just described along with the algorithms above for the 41 standard cases, we can solve almost any F2L. The only exception is when none of the four edges and four corners of F2L are on the U layer, in which case an unsolved slot (say at FR) must be brought to the U layer, for example by RUR'. Otherwise, we can solve any every corner-edge pair by bringing the target slot (or the wrong slot containing a corner or an edge) to FR. Repeating this four times, one for each pair, completes the F2L.

    Real F2L: In practice, however, bringing the target slot to FR is often a waste of time. To increase speed, we must minimize whole cube turns and maximize finger tricks, which usually involve RU or LU combinations. Both of these can be achieved by learning to use the three target slots other than FR. Although some cases have special algorithms for different target slots, at the start it is enough to learn the algorithms given above for the 41 standard cases from different directions. This can be accomplished in part by understanding how the algorithms work.

    We start by reexamining the examples from the preceding section.

    Example 1

    As before, we start with RU'R' to reduce the case to I2. Instead of bringing the target slot to FR, we can directly insert the corner-edge pair into the BL slot with LU2L'.

    Full solution: RU'R'-LU2L'.
    Example 2

    Again, we start with U'RUR'. Since the corner is above BR, we bring the target slot here with Dw'. The remaining basic pattern is then solved as R'U'R.

    Full solution: U'RUR'-Dw'-R'U'R.
    Example 3

    Here the wrong slot is BR. R'UR brings the corner-edge pair to U, and this basic pattern is solved with RU'R.. It is useful to be familiar with the full solution.

    Full solution: R'UR2U'R'.

    Things become slightly more difficult for cases other than the four standard ones.

    Example 4

    This is U1 with the target slot BR. Rather than bringing the target slot to FR with y and doing D'wL'U2L-U'L'UL, we perform the algorithm from a different angle.

    Full solution: U'R'U2R-U'R'UR.

    The two-step structure of the original algorithm is preserved in this solution. In such cases, understanding how the original algorithm therefore makes it much easier to use it use it from different angles.
    Example 5

    This is M2 with the target slot BR. Since the algorithm for M2 was not intuitive, here we simply have to get used to the algorithm performed from different directions. To maximize finger tricks, we need the target slot at either FL or BR.

    Full solution: R2U2'RUR'UR2.

    Empty Slot

    When we are solving the first three corner-edge pairs, at least one slot is not yet solved; we call these empty slots (visually, a gray slot in the applet). Algorithms with the usual two-step structure can be simplified significantly using empty slots. The following examples demonstrate this.

    Example 6

    This is Q2 with target slot FR and empty slot BL. Perform the first step of Q2 as if the target slot were BL: LUL'. This places the pair into a basic position, which then can easily be solved into the real target solt: RU'R'. Note that we need to be comfortable with different angles and target slots before we can effectively use this technique.

    Full solution: LUL'RU'R' (2 moves saved).

    Here are some more examples with various empty and target slots.

    R'UR-U'RUR'

    Empty: BR
    Target: FR
    R'U2R-RUR'

    Empty: BR
    Target: FR
    R'UR-RUR'

    Empty: BR
    Target: FR
    RUR'U-R'U'R

    Empty:FR
    Target:BR
    R'U'R-UL'UL

    Empty:BR
    Target:FL
    R'U2'R-UL'UL

    Empty:BR
    Target:FL

    Here are more applications of empty slots:

    Example 7

    Even if the resulting algorithm has the same number of moves, empty slot may allow us to eliminate awkward whole cube turns. Without empty slot, we would first need to rotate the cube with y (or y'), place the pair into a basic position, and do Dw (or D'w, respectively) before solving this. Instead, we have

    Full solution: UL'ULURUR'
    Example 8

    The empty slot can stay on U during pair insertion. Here, B' creates a basic pattern, which is solved by RUR'. A final B restores the empty slot. Unfortunately, this example is a bit hard to see and also requires regripping.

    Full solution: B'RUR'B
    Example 9

    Yet another application of empty slot is to cases where the target slot already has a corner or an edge solved. The target and empty slot here are FR and FL, respectively. We do D' to bring the target corner to the empty slot, which allows us to solve the corner with L'UL. The bottom layer is then corrected: D. Note that we actually only needed the empty edge FL; this is a special case of mismatched pair, our next topic. Full solution: D'-L'UL-D

    Learning to recognize these cases is a skill that requires time to acquire. Once developed, it allows us to choose the easiest corner-edge pair for each of the four slots most of the time.

    Mismatched Pair

    Also known as "misaligned pair," mismatched pair refers to solving a corner and an edge from two different slots at the same time. We need to pretend that they form a corresponding corner-edge pair and determine the appropriate F2L case. This comes in handy when there are two slots, one with the corner solved and the other with the edge solved.

    Although not as common as the other standard techniques, mismatched pair allows us to shorten our solution significantly by solving in one step what would otherwise require two steps.

    Example 10

    Note that the FR slot has the corner solved and BL the edge. The two remaining pieces of these slots are shown. Since the two slots are across the diagonal, we replace each color on the edge by its opposite to deduce that this is equivalent to case L1. First do D2 to create a mixed target slot at FR. Then do L1: U'RU'R'URUR'. Finally, replace the slots with D2.

    Full solution: D2-U'RU'R'URUR'-D2
    Example 11

    Recognition becomes slightly trickier when the two slots are adjacent. One method is mentally flip the edge and focus on the color shared by the two slots (yellow in this case). Ignoring red and orange, this shows that the correct case is U1. We can also save a whole cube turn by creating the mixed slot using Uw.

    Full solution: Uw-L'U2LU'L'UL-Uw'

    Looking Ahead and Simple Multislotting

    In Getting Fast with an Easy Method and elsewhere, I've repeatedly stressed the importance of looking ahead. By solving slower than at top speed and looking for the next corner-edge pair as you solve one, you eliminate gaps between pairs, making F2L into one seamless motion. While this allows you to always choose the easiest next pair, once the pair is chosen, the techniques covered so far apply just to this one pair

    In certain special cases, instead of merely anticipating the next pair, you can use looking ahead as an active tool; in multislotting, the current pair is solved so as to create the next pair, or to at least simplify it. Although true multislotting requires many extra algorithms, a good look-ahead suffices for the simplest types explained here.

    Example 12

    Using the empty slot BR, you pair with LUL'. At this point, because you have been looking ahead, you notice that the edge currently at FR can be paired with its corresponding corner if you insert the current pair by URU2'R'. The standard insertion RU'R' would not have produced a nice next pair.

    Normal solution: LUL'-RU'R'
    Better solution: LUL'-URU2'R'
    Example 13

    A very similar example, with the first pair already made. In practice you would end up here while solving that pair and then realize to use this alternative insertion. You should be able to imagine a few more examples of the same type.
    Example 14

    This is a lot more sophisticated. Say UFR-FR is the pair you were looking at during the previous pair, so you start solving this with U'R'FRF'. Completely by accident (unless you know multislotting algorithms), this makes another pair! Instead of the normal insertion RU'R', you insert this new pair first and come back to the first pair later, with a cancellation you can also avoid by looking ahead or just by knowing this two-pair insertion: B'RB(R'R)U'R'.

    Full solution: U'R'FRF'B'RBU'R'

    To be sure, a good anticipatory look-ahead is already very, very advanced (sub-15 level). Even for very experienced speedcubers, unless they know multislotting algorithms, these (basically) accidental multislotting do not occur very often. But when they do happen, they often lead to extremely fast single solves.

    These examples give you a taste of advanced F2L. Hopefully, you're now convinced that F2L is the most intricate step, and that it is the step with the most opportunities for dramatic speed-ups.

    Sample F2Ls

    Scramble (with cross on bottom): DLB'U'F2L2DB'L'U'B'F'L2F'D2L2R2FL2F'UF'D'B'L'

    Cross: RD2F'UwR
    1st Slot: yURU'R'-U2'R'UR (wrong target FR, target slot BR)
    2nd Slot: y'RUR'-R'U'R (wrong slot FR, target slot BR)
    3rd Slot: L2'U2LUL'UL2 (target slot FL)
    4th Slot: y'U2'R'UR-U'R'U'R (target slot BR)

    F2L total: 29 moves (1 double layer), 3 whole cube turns
    Scramble (with cross on bottom): B'U2L'B2F'R'U2R'F'B2U'LRF'B2R'L2U'LR'BF2RFR'

    Cross: D'L'B'F'D'
    1st Slot: U'LUL'-RU'R' (empty slot BL, target slot FR)
    2nd Slot: yRU'R'-R'UR (wrong slot FR, target slot BR)
    3rd Slot: yR'U'R-U'R'UR (target slot BR)
    4th Slot: y'RU2'R'-DwR'U'R (target slot FR)


    F2L total: 27 moves (1 double layer), 3 whole cube turns

    As a final note, none of the techniques discussed here deals with cases where there is no corner and no edge on top. Some special cases of this will be addressed in the advanced F2L section; for the rest, we need to spend three moves (for example, RUR') to bring some F2L pieces to the top layer.


  • Best viewed in Firefox
    Resolution 1024x768
    Created by
    Shotaro Makisumi

    Chatter