
It's really important to start timing your solves if you want to improve your speeds. Even though StackMat timer is the official choice, you don't have to have one in order to time your solves. Here are a few pretty neat online timers that you can use on your computer or phone.

- [csTimer](https://www.cstimer.net) ([Source](https://github.com/cs0x7f/cstimer))

  - Can be used offline and installed as a PWA
  - Ability to use WCA Inspection
  - Very customizable UI and options
  - Scramble image
  - Cloud sync with Google, [WCA](https://www.worldcubeassociation.org/) or csTimer account

- [qqTimer](https://www.qqtimer.net/) ([Source](https://github.com/cubing/qqtimer))

  - Minimalistic UI
  - Can be used offline
  - Inspection support
  - Import functionality

  The original version of this timer was made by [Michael Gottlieb](http://mzrg.com/) and is available [here](http://mzrg.com/qqtimer/) ([GitHub](https://github.com/qqwref/qqTimer)).

- [Twisty Timer](https://play.google.com/store/apps/details?id=com.aricneto.twistytimer&hl=en_US&gl=US) ([Source](https://github.com/aricneto/TwistyTimer)) (Android)

  - Nice UI with a range of themes and customizations
  - Supports import/export
  - Includes OLL and PLL trainer and algorithms reference in-app
  - Supports inspection
  - Ability to enable Hints for Cross/Extended Cross on 3x3
  - Scramble image

- [ChaoTimer](https://apps.apple.com/us/app/chaotimer-professional-cube-timer/id537516001) (iOS)

  - Supports a range of gestures

- [Timiks](https://timiks.com/) ([Source](https://github.com/ngerritsen/timiks))

  - OLL/PLL trainer
  - Customizable UI
  - Cloud sync with Google

- [timer.cubing.net](https://timer.cubing.net/) ([Source](https://github.com/cubing/timer))

  - Minimal design
  - Works offline on mobile as a PWA
  - Sync functionality

- [cTimer](http://www.ctimer.co.uk/)

  - Dark mode
  - Supports inspection
  - Scramble image

  cTimer is made by [Conrad Rider](http://rider.biz/), maker of [VisualCube](http://cube.rider.biz/visualcube.php) and [other cubing software](http://cube.rider.biz/).

- [Ruwix Timer](https://ruwix.com/online-rubiks-stopwatch-timer/)
  - Customizable theme and design
  - Scramble image + graph
  - Supports inspection

There are tons of timers out there but I think these options are pretty great for any use case that you might have. Enjoy!


You don't need a StackMat timer

[Top]


In this guide, I will explain how 4-look last layer (4LLL) in CFOP works and provide the best algs and recommendations that will help to learn the full set later down the road.

Basically, the idea is to solve the last layer in no more than 4 steps. First you orient the last layer using a maximum of 2 algs and then permute the last layer using a max of 2 algs:

1. Edge Orientation (3 algs)
2. Corner Orientation (7 algs)
3. Corner Permutation (2 algs)
4. Edge Permutation (4 algs)

The total number of algs required for 4-look last layer is 10+6 = 16 whereas full OLL and PLL consist of a total of 57+21 = 78 algs. For beginners, this makes it a lot less intimidating and a lot more sense to learn 4-look LL first.

## 2-look OLL (10 algs)

**Steps**:

1. Orient the edges using one of 3 algs
2. Orient the corners using one of 7 algs

After F2L, there are 3 cases (excluding the one where all 4 edges are already oriented) that you can get:

- I shape (2 opposite edges oriented)
- L shape (2 adjacent edges oriented)
- Dot (No edges oriented)

| Cases                                                                  | Algs                                                                                             | Notes    |
| ---------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------ | -------- |
| ![45](https://github.com/rsapkf/20/raw/main/3x3/cfop/oll/svg/45.svg) | <ul><li>F (R U R' U') F'</li></ul>                                                               | OLL 45   |
| ![44](https://github.com/rsapkf/20/raw/main/3x3/cfop/oll/svg/44.svg) | <ul><li>f (R U R' U') f'</li><li>y2 F (U R U' R') F'</li></ul>                                   | P/OLL 44 |
| ![2](https://github.com/rsapkf/20/raw/main/3x3/cfop/oll/svg/2.svg)   | <ul><li>F (R U R' U') F' f (R U R' U') f'</li><li>F (R U R' U') F' U2 F (U R U' R') F'</li></ul> | OLL 2    |

Instead of using specifically OLL 45/44/2 algs, you could use one of many algs for cases that have I shape (27 OLLs), L shape (15 OLLs) and a Dot (8 OLLs) in them respectively. These algs are usually recommended because they are the easist to learn.

After the edges are correctly oriented, you can get one of the following 7 cases. I highly recommend learning alternative algs for more common cases like Sune and Antisune because a lot of OLLs have variations of Sune, Antisune and their mirrors in them. This will make it easier to learn full OLL.

| Cases                                                                  | Algs                                                                                                                    | Notes                    |
| ---------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------- | ------------------------ |
| ![27](https://github.com/rsapkf/20/raw/main/3x3/cfop/oll/svg/27.svg) | <ul><li>(R U R' U R U2 R')</li><li>y' R' U2 R U R' U R</li></ul>                                                        | Sune/OLL 27              |
| ![26](https://github.com/rsapkf/20/raw/main/3x3/cfop/oll/svg/26.svg) | <ul><li>(R U2 R' U' R U' R')</li><li>y' R' U' R U' R' U2 R</li></ul>                                                    | Antisune/OLL 26          |
| ![23](https://github.com/rsapkf/20/raw/main/3x3/cfop/oll/svg/23.svg) | <ul><li>R2 D (R' U2 R) D' (R' U2 R')</li><li>y2 R2 D' (R U2 R') D (R U2 R)</li></ul>                                    | U/OLL 23                 |
| ![24](https://github.com/rsapkf/20/raw/main/3x3/cfop/oll/svg/24.svg) | <ul><li>(r U R' U') (r' F R F')</li><li>y (R U R D) (R' U' R D') R2</li></ul>                                           | T/OLL 24                 |
| ![25](https://github.com/rsapkf/20/raw/main/3x3/cfop/oll/svg/25.svg) | <ul><li>y F' (r U R' U') r' F R</li></ul>                                                                               | L/Bowtie/OLL 25          |
| ![22](https://github.com/rsapkf/20/raw/main/3x3/cfop/oll/svg/22.svg) | <ul><li>R U2' (R2' U') (R2 U') R2' U2' R</li></ul>                                                                      | Pi/Air Jeff/Bruno/OLL 22 |
| ![21](https://github.com/rsapkf/20/raw/main/3x3/cfop/oll/svg/21.svg) | <ul><li>(R U2 R') (U' R U R') (U' R U' R')</li><li>y (R U R' U) (R U' R' U) R U2 R'</li><li>F (R U R' U')3 F'</li></ul> | H/OLL 21                 |

## 2-look PLL (6 algs)

**Steps**:

1. Permute the corners using one of 2 algs
2. Permute the edges using one of 4 algs

When you are done with OLL, there are broadly 2 cases (excluding the one where all 4 corners are already permuted) that can appear:

- Headlights (One set of adjacent corners need to be swapped)

  Put the headlights on the left and apply T Perm.

- No headlights (One set of diagonal corners need to be swapped)

  Apply Y/Nb Perm from any angle.

Remember, instead of T and Y/Nb perms, any other algorithm that swaps one set of adjacent corners (Ra, Rb, Ja, Jb, F) or diagonal corners (Na, V) while swapping one set of edges can be used respectively. Since T and Y/Nb perms are the easiest to learn, these are usually recommended.

| Cases                                                                | Algs                                                                                                                 | Notes     |
| -------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------- | --------- |
| ![T](https://github.com/rsapkf/20/raw/main/3x3/cfop/pll/svg/T.svg) | <ul><li>(R U R' U') (R' F R2 U') R' U' (R U R' F')</li></ul>                                                         | T Perm    |
| ![Y](https://github.com/rsapkf/20/raw/main/3x3/cfop/pll/svg/Y.svg) | <ul><li>F (R U' R' U') (R U R' F') (R U R' U') (R' F R F')</li><li>(R' U L' U2 R U' L) (R' U L' U2 R U' L)</li></ul> | Y/Nb Perm |

After permuting the corners, apply one of these 4 algs to finally solve the cube:

| Cases                                                                  | Algs                                                                                                                              | Notes   |
| ---------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------- | ------- |
| ![Ub](https://github.com/rsapkf/20/raw/main/3x3/cfop/pll/svg/Ub.svg) | <ul><li>R2 U (R U R' U') R' U' (R' U R')</li><li>y2 (R' U R' U') R' U' (R' U R U) R2</li></ul>                                    | Ub Perm |
| ![Ua](https://github.com/rsapkf/20/raw/main/3x3/cfop/pll/svg/Ua.svg) | <ul><li>(R U' R U) R U (R U' R' U') R2</li><li>L2 U' (L' U' L U) L U (L U' L)</li><li>y2 (R2 U' R' U') R U R U (R U' R)</li></ul> | Ua Perm |
| ![H](https://github.com/rsapkf/20/raw/main/3x3/cfop/pll/svg/H.svg)   | <ul><li>(M2 U M2) U2 (M2 U M2)</li></ul>                                                                                          | H Perm  |
| ![Z](https://github.com/rsapkf/20/raw/main/3x3/cfop/pll/svg/Z.svg)   | <ul><li>(M2 U M2 U) (M' U2) (M2 U2 M')</li><li>y/y' (M2 U' M2 U') (M' U2) (M2 U2 M')</li></ul>                                    | Z Perm  |

Grok these algs and with good fingertricks, hardware, and decent lookahead during F2L, it's actually possible to be sub 30 on the 3x3.

## 3-look last layer

If you have learned 4LLL, the transition to learning the full set of algs for 2LLL is not as easy. It is recommended to learn full PLL first, then gradually pickup the remaining OLLs. This phase is known as "3LLL" or "3-look last layer". You would have to learn at least 10+21=31 algorithms to be able to solve the last layer in at most 3 algs.

## Further reading

- [CubeSkills - 4 Look Last Layer Algorithms](https://www.cubeskills.com/uploads/pdf/tutorials/4-look-last-layer.pdf)


A definitive guide to 4-look last layer (CFOP)


One overlooked aspect of teaching PLL to beginner CFOP solvers in many tutorials online is PLL recognition. Unlike OLL cases that are generally easier to identify, have shorter algorithms and familiar triggers, PLL algorithms are longer and recognizing PLL cases takes a bit of effort. If you are a beginner CFOP learner who knows the basics (2-look PLL) and want to learn full PLL and find the task daunting, this guide will help you recognize, learn and practice PLL algs in no time.

PLL cases are usually represented by drawing arrows showing which pieces need to swap places. They are named using English alphabets which are chosen to roughly resemble the pattern of these arrows. But that can sometimes be confusing. So to give a simpler and more efficient way, I will completely omit the arrows from visualizations and will go over some basics first.

Out of 21 cases, only 13 are distinct. Other PLLs are either mirrors or inverses. For e.g. Ua perm is the mirror of Ub, meaning if you apply Ua alg to Ub case but by mirroring your moves with the left hand, you'll be able to solve Ub.

The 13 distinct perms are:

- U (Ua, Ub) \*
- H \*
- Z \*
- T (Adjacent corner swap alg in 2-look PLL) \*
- Y (Diagonal corner swap alg in 2-look PLL) \*
- F
- E
- V
- A (Aa, Ab)
- J (Ja, Jb)
- R (Ra, Rb)
- N (Na, Nb)
- G (Ga, Gb, Gc, Gd)

_\* 2-look PLL algs_

To recognize the rest, we will look whether certain "features" are available. There are 5 main features that are easily noticeable in PLL cases:

## Headlights

If you see one or more face on the last layer (LL) where two corner stickers have the same color and the middle one has either an adjacent or an opposite color, that's a headlight. 11 out of 21 PLLs have a headlights feature.

A "connected headlight" is when a 1x2 block is connected to a headlight. Depending on the case, there can be either 0, 1 or 2 connected headlights.

PLLs: **A**, **T**, **R**, **G** (+ **H**, **Z**)

| Name               | PLL                                                                                                                                                                                                                                                                                         | Notes                                                                                                                                  |
| ------------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------- |
| A (Aa, Ab)         | ![Aa](https://github.com/rsapkf/20/raw/main/3x3/cfop/pll/svg/Aa.svg) ![Ab](https://github.com/rsapkf/20/raw/main/3x3/cfop/pll/svg/Ab.svg)                                                                                                                                               | <ul><li>Adjacent color between headlights</li><li>No connected headlights</li></ul>                                                    |
| R (Ra, Rb)         | ![Ra](https://github.com/rsapkf/20/raw/main/3x3/cfop/pll/svg/Ra.svg) ![Rb](https://github.com/rsapkf/20/raw/main/3x3/cfop/pll/svg/Rb.svg)                                                                                                                                               | <ul><li>Adjacent color between headlights</li><li>1 connected headlight</li></ul>                                                      |
| T                  | ![T](https://github.com/rsapkf/20/raw/main/3x3/cfop/pll/svg/T.svg)                                                                                                                                                                                                                        | <ul><li>Opposite color between headlights</li><li>2 connected headlights</li></ul>                                                     |
| G (Ga, Gb, Gc, Gd) | ![Ga](https://github.com/rsapkf/20/raw/main/3x3/cfop/pll/svg/Ga.svg) ![Gb](https://github.com/rsapkf/20/raw/main/3x3/cfop/pll/svg/Gb.svg) ![Gc](https://github.com/rsapkf/20/raw/main/3x3/cfop/pll/svg/Gc.svg) ![Gd](https://github.com/rsapkf/20/raw/main/3x3/cfop/pll/svg/Gd.svg) | <ul><li>Ga/Gc - Adjacent color between headlights, Gb/Gd - Opposite color between headlights</li><li>No connected headlights</li></ul> |
| H                  | ![H](https://github.com/rsapkf/20/raw/main/3x3/cfop/pll/svg/H.svg)                                                                                                                                                                                                                        | <ul><li>Headlights on all sides</li><li>No connected headlights</li></ul>                                                              |
| Z                  | ![Z](https://github.com/rsapkf/20/raw/main/3x3/cfop/pll/svg/Z.svg)                                                                                                                                                                                                                        | <ul><li>Headlights on all sides</li><li>No connected headlights</li></ul>                                                              |

## 1x3 block

Only 5 out of 21 cases have a 1x3 block of solved pieces on the last layer.

PLLs: **J**, **F**, **U**

| Name       | PLL                                                                                                                                           | Notes                                                                                       |
| ---------- | --------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------- |
| J (Ja, Jb) | ![Ja](https://github.com/rsapkf/20/raw/main/3x3/cfop/pll/svg/Ja.svg) ![Jb](https://github.com/rsapkf/20/raw/main/3x3/cfop/pll/svg/Jb.svg) | <ul><li>1 connected 1x3 block</li><li>Adjacent colors pair next to the 1x3 block</li></ul>  |
| F          | ![F](https://github.com/rsapkf/20/raw/main/3x3/cfop/pll/svg/F.svg)                                                                          | <ul><li>No connected 1x3 block</li><li>Opposite colors pair next to the 1x3 block</li></ul> |
| U (Ua, Ub) | ![Ua](https://github.com/rsapkf/20/raw/main/3x3/cfop/pll/svg/Ua.svg) ![Ub](https://github.com/rsapkf/20/raw/main/3x3/cfop/pll/svg/Ub.svg) | <ul><li>Easy cases</li></ul>                                                                |

## 1x2 block

10 PLLs have 1x2 blocks on the last layer in them.

PLLs: **J**, **N**, **Y**, **G**

| Name               | PLL                                                                                                                                                                                                                                                                                         | Notes                                        |
| ------------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | -------------------------------------------- |
| J (Ja, Jb)         | ![Ja](https://github.com/rsapkf/20/raw/main/3x3/cfop/pll/svg/Ja.svg) ![Jb](https://github.com/rsapkf/20/raw/main/3x3/cfop/pll/svg/Jb.svg)                                                                                                                                               | <ul><li>3 1x2 blocks (+1 full bar)</li></ul> |
| N (Na, Nb)         | ![Na](https://github.com/rsapkf/20/raw/main/3x3/cfop/pll/svg/Na.svg) ![Nb](https://github.com/rsapkf/20/raw/main/3x3/cfop/pll/svg/Nb.svg)                                                                                                                                               | <ul><li>4 distinct 1x2 blocks</li></ul>      |
| Y                  | ![Y](https://github.com/rsapkf/20/raw/main/3x3/cfop/pll/svg/Y.svg)                                                                                                                                                                                                                        | <ul><li>2 1x2 blocks</li></ul>               |
| T                  | ![T](https://github.com/rsapkf/20/raw/main/3x3/cfop/pll/svg/T.svg)                                                                                                                                                                                                                        | <ul><li>2 1x2 blocks</li></ul>               |
| G (Ga, Gb, Gc, Gd) | ![Ga](https://github.com/rsapkf/20/raw/main/3x3/cfop/pll/svg/Ga.svg) ![Gb](https://github.com/rsapkf/20/raw/main/3x3/cfop/pll/svg/Gb.svg) ![Gc](https://github.com/rsapkf/20/raw/main/3x3/cfop/pll/svg/Gc.svg) ![Gd](https://github.com/rsapkf/20/raw/main/3x3/cfop/pll/svg/Gd.svg) | <ul><li>1 1x2 block</li></ul>                |

## 2x2 square

This is just a solved 2x2 block on the top layer. 3 PLL cases have this feature.

PLLs: **A**, **V**

| Name       | PLL                                                                                                                                           | Notes                                                                            |
| ---------- | --------------------------------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------- |
| A (Aa, Ab) | ![Aa](https://github.com/rsapkf/20/raw/main/3x3/cfop/pll/svg/Aa.svg) ![Ab](https://github.com/rsapkf/20/raw/main/3x3/cfop/pll/svg/Ab.svg) | <ul><li>Has headlights</li><li>Same color in the diagonal corners</li></ul>      |
| V          | ![V](https://github.com/rsapkf/20/raw/main/3x3/cfop/pll/svg/V.svg)                                                                          | <ul><li>No headlights</li><li>Different colors in the diagonal corners</li></ul> |

## No features

PLLs: **E**

![E](https://github.com/rsapkf/20/raw/main/3x3/cfop/pll/svg/E.svg)

The main feature of the **E** perm is that it has no features. You can look around the last layer and see that there aren't any headlights, full bars, half-bars, or 2x2 squares.

This is just a beginner's guide to PLL recognition. There are advanced techniques that can help you recognize PLL by looking at just 2 sides of the last layer. Check out the links below to learn more.

## Further reading

- [badmephisto - Recognizing the PLLs (2009)](https://www.youtube.com/watch?v=qBYycb7hR4Y/)
- [CubeSkills - PLL Algs](https://www.cubeskills.com/uploads/pdf/tutorials/pll-algorithms.pdf)
- [CubeSkills - PLL Recognition Trainer](https://www.cubeskills.com/tools/pll-recognition-trainer) - 2 side PLL recognition trainer.
- [AlgDb.net - PLL](http://algdb.net/puzzle/333/pll/)
- [JPerm.net - PLL Trainer](http://jperm.net/algs/pll)
- [Speedsolving Wiki - PLL](https://www.speedsolving.com/wiki/index.php/PLL/)
- [How I Recognize PLL Fast](https://www.youtube.com/watch?v=sdz5EjWShCg), [Advanced PLL Recognition](https://www.youtube.com/watch?v=_gIAQm_B170) - J Perm

## Credits

All visualizations in this guide were created using [VisualCube](http://cube.rider.biz/visualcube.php).
