Welcome to the Speedsolving.com, home of the web's largest puzzle community! You are currently viewing our forum as a guest which gives you limited access to join discussions and access our other features.

Here is my PLL compilation that I made. I put some of the popular ones in, as well as some of my own and ones that I could not find online. Although this is not as thorough as some other compilations, I tried to include the best algorithms I know. Some of these can be used for OH and others are easy to learn. All the algorithms also include a link to an animation of the algorithm. Find the algorithms that work best for you! Read the notes in the documents before trying them. Learning finger tricks is recommended for these algorithms. Reply down below if you have any suggestions for algorithms and I will try to add in the best ones. Thanks!

This is a currently unfinished list, I will update it when I have the time. I will turn off viewing when I am editing.

When you are conjugating PLLs to make ZBLLs, make sure to place your F2L pairs at spots where there would normally be blocks or bars. DO NOT USE THE E PERM, F PERM OR EPLLs

I was bored with my online class so I was messing with PLLs. I got these ZBLLs and many more. Can you compare these with your current algs @PapaSmurf@GenTheThief ?

>R' U R2 u R' U R' U' R u' R2 F' U F U' R
>R U' R2 u' R U' R U R' u R2 f R' f' U R'
>F R2 F2 R U2 R U2 R' F R U R' U' R' F R2 F'
I use RUD algs for these (R2 D' R U2 R' U' D R' U' R2 U R U R2, which is just the COLL cancelling into a U perm). Haven't bothered to learn the recognition for the inverse cases.

>z S' R U R' U' R' F R2 U' R' U' R U R' F' S z'
Standard alg (r U' r U2 R' F R U2 r2 F) is way better.

>F r' D' F r U' r' F' D r2 U r' U' r' F r F2
The F2 at the end seems awful. Unfortunately, afaict all "good" algs for this case are N perm setups, which also means there are no truly good algs. (I use a different N perm setup.)

>x U R' U R' D2 R U' R' D2 R2 U' x'
Standard alg (R' U2 R' D' R U2 R' D R2) is the standard COLL alg for this case already.

>F' R U R' F' R U R' U' R' F R2 U' R' F
Standard alg (R2 D r' U2 r D' R' U2 R') is way shorter.

>x U R2 F R F' R U2 r' U r U x'
Standard RUL algs are probably better. Interesting, though. (I've been toying with this RUD alg for this case but it doesn't seem that great.)

>F R U R' F' R U2 R' U2 R' F R U R U2 R' U' F'
Standard alg is a J perm setup: R U D' R U R' D R2 U' R U R2 U2 R' = [R U z' : R' U L U' R U2 L' U L U2 L'].

I'd do
COLL cancel into RUS U perm. ((U') F U2 R' U' R F' R' U2 F U F' U' R also exists.)
COLL cancel into RUS U perm. (Inverse of the alg above also works).
Same priniciple as the last 2.
Same principle as the last 3.
F' r2 U2 R' F' R U2 r' U r'
F R U R' U' S D' R' F' R D f' R' F R (I should switch to this anyway).
Same principle as first 4.
R' U2 R' D' R U2 R' D R2
Same principle as first 4.
I use a bad alg for this case, but try F U' R' U R D R' U R D'U F' R' U R or f R U R2 F R f' R S U' S' R' F'
R2 D r' U2 r D' R' U2 R'
L' U2 R U' R' U2 L R U' R', inverse or (U) l' U2 L2 F' L' F L' U2 l

Here is my PLL compilation that I made. I put some of the popular ones in, as well as some of my own and ones that I could not find online. Although this is not as thorough as some other compilations, I tried to include the best algorithms I know. Some of these can be used for OH and others are easy to learn. All the algorithms also include a link to an animation of the algorithm. Find the algorithms that work best for you! Read the notes in the documents before trying them. Learning finger tricks is recommended for these algorithms. Reply down below if you have any suggestions for algorithms and I will try to add in the best ones. Thanks!

This is a currently unfinished list, I will update it when I have the time. I will turn off viewing when I am editing.

For OH, this E perm actually seems good despite the length:
F U' R U' R' U2 R U' R' U R' U2 R U R' U R F'

If you take out the F moves, this is just solving the last slot's corner and then doing a back Antisune. It's the fastest one I've tried so far. And yes, I know about the one that starts with hedge and ends with some f moves.

The other PLL cases that can be solved with F-2gen-F' are U perms (useless), T perm (bad algs), G perms (haven't triedall bad) and V perm (meh algs).

It's probably common knowledge to people who've tried genning ZBLL algs that half of the diag ZBLLs can be solved with F-RU-F', with the only exceptions being those with pieces permuted like the N perms or Y perm. Most of these F-RU-F' diag ZBLL algs are awful (long and/or has overturning), but there are a few that aren't. Here are the F-RU-F' diag ZBLLs that I use (or used to use):

F U' R U' R' U2 R U' R' U R' U2 R U R' U R F' (E perm from the quoted post above; OH only)
F R U' R2 U2 R U R' U R2 U R' F' and inverse (ZBLL S/AS; OH only)
F R U R' U R U2 R U2 R2 U' R2 U' R2 F' and inverse (ZBLL S/AS)
F U' R2 U R' U R U2 R2 U' R U2 R' F' and inverse (ZBLL T)
F R U' R' U' R U2 R' U' R U' R' U' R U2 R' U' F' (ZBLL U)
F sexy3 F' and inverse (ZBLL H; F sexy3' F' solves same case but may be better depending on grip)
F R2 U' R U' R U' R' U2 R' U R2 F' and inverse (ZBLL pi; OH only)
F U R' U' R2 U' R2 U2 R U2 R U R' F' (ZBLL pi)

It's fairly easy to convert F-RU-F' algs to Fw-RU-Fw' algs too (replace F/F' with Fw/Fw' and swap U/U' with R/R'), but I don't like Fw moves so I don't know or care if any of the Fw versions are better (by having less regrips/overturning etc.).

Some adj ZBLLs can also be solved like that, but the proportion is smaller (5/12 = 42%). I haven't learnt the full set of adj ZBLLs, so obviously I can't give a full compilation of "good" F-RU-F' algs, but here are some examples:

F R U R' U' R U' R' U' R U R' F' and inverse (ZBLL T/U)
F U R U2 R' U R U R' F' and inverse (ZBLL T/L)
F U R U' R' U R U2 R' U' R U R' F' and inverse (ZBLL pi/H)

One interesting feature of the F-RU-F' ZBLL algs is that they always preserve the UF edge. This is because the F move flips it while moving it to RF, so it has to be flipped back, and the only way it can be flipped back is if after all the ⟨R,U⟩ moves it gets sent to RF; then after the F' move it's back where it started. This makes AUF prediction much easier to memorise. (This is not true of the F-RU-F' 1LLL algs in general, e.g. F R U R' U' F'.)

There are also some F-RUS-F' ZBLL algs that are worth using, such as F R2 U' R2 U R2 U S R2 f' = F R2 U' R2 U R2 U (S R2 S') F'. Since S R2 S' / S' U2 S preserve edge orientation, some of these algs also preserve the UF edge, but this is no longer guaranteed (because nobody said you had to use S moves only as part of S R2 S' or S' U2 S). Conversely, short F-RUS-F' ZBLL algs that preserve the UF edge are likely to use S moves only within S R2 S' or S' U2 S.

(edit: fixed a calculation error that led to the mistaken statement that most diag ZBLLs can be solved with F-RU-F', which was very incorrect. we regret the mistake etc.)

That Jb is used as an adjacent swap alg in 2x2 and its bad for 3x3. However, a variation of this alg, L' U R U' L U2 R' U R U2 R' is used by some people for OH, the Ja is a variation of R' U L' U2 R U' R' U2 R r but it's ok and the Nb is a variation of (R' U L' U2 R U' L)2 which I used to use. The M' isn't worth it though. You can write it as r R'.

Using a stochastic program, I've just discovered an algorithm for OLL 29:

R'U'F'UL'FRF'LF
The algorithm contains only 10 moves, shorter than any existing one that I've known.
However, I found it not very practical to use, very against human-nature, I mean..