Regripless Orozco with UR-RD buffer + helper

[Aergyl]

This is a variant of Orozco for edges with no regrips and no grip shifts, using UR as buffer and RD as helper. More precisely, the left thumb and middle finger always stays on the center of the F face and the B face, and the right thumb and middle finger always stays on the FR and the BR sticker (except when double flicking). Here are the algorithms written in commutator notation:

RD = (do nothing)
DR = S' , U R' F U' R
UL = R U' : F , R' S R
LD = R' D : R S' R' , F'
LU = D' : R' F' R , S
DL = U : S' , R F R'
FR = S' , R U' R' U
BR = S' , R' U' R U
RF = R' D R D' , S
RB = R D R' D' , S
UF = R F R' , S
DF = R F' R' , S
LF = R F2 R' , S
FU = S' , R' F R
FD = S' , R' F' R
FL = S' , R' F2 R
UB = R' B' R , S
DB = R' B R , S
LB = R' B2 R , S
BU = S' , R B' R'
BD = S' , R B R'
BL = S' , R B2 R'

Some cases have other decent alternatives, and there are also better algorithms for a few cases if you allow grip shifts (most notably if you allow E-moves), but I just thought this was a fun idea, and that the execution would look pretty cool

 

[Aergyl]

Actually, I might as well add regripless Orozco corners while I'm at it, using UFR as buffer and UBR as helper:

Parity (UFR-UBR + UR-RD swap): R U' R' U S' U R U' R' U' f R' F' R

UBR = (do nothing)
BUR = R' D R D' R' D R , U
RUB = U , R' D R D' R' D R
UFL = R F' R' : U , R' D R
DFL = R F' : D , R' U' R
UBL = R' B R : R D' R' , U'
DBL = R' B : R U R' , D'
FUL = R2 U' R2 : R D R' , U'
BUL = R2 U R2 : U , R' D' R
LUF = R' U' R : U' , R D R'
LUB = R U R' : R' D' R , U
DFR = U , R2 D' R2 D R2
DBR = R2 D R2 D' R2 , U'
RUF = U , R' D' R
LUF = U , R' D R
FUR = D' : U , R' D R
FUL = D : U , R' D' R
RUB = R D R' , U'
LUB = R D' R' , U'
BUR = D : R D' R' , U'
BUL = D' : R D R' , U'

Once again, there are other decent alternatives for some of the cases. Also some fingertricks might not be obvious. I'll explain FUL as an example. IMO it's best executed as R2' U' R3 D R' U' R D' R' U R2' U R2, using the right ring finger for the first U' and the last U (left index finger is fine as well). BUL is essentially the same, and I would execute it like l2 D l2' U R' D' R U' R' D R l2 D' l2'.

 

[johnwood]

That’s an interesting variant of the Orozco method you’ve described. It seems like you have put a lot of thought into optimizing finger placement and minimizing reg rips. The algorithms you’ve provided in commutator notation look well-designed for this specific approach. Keep up the good work!

 

[OreKehStrah]

This is a variant of Orozco for edges with no regrips and no grip shifts, using UR as buffer and RD as helper. More precisely, the left thumb and middle finger always stays on the center of the F face and the B face, and the right thumb and middle finger always stays on the FR and the BR sticker (except when double flicking). Here are the algorithms written in commutator notation:

RD = (do nothing)
DR = S' , U R' F U' R
UL = R U' : F , R' S R
LD = R' D : R S' R' , F'
LU = D' : R' F' R , S
DL = U : S' , R F R'
FR = S' , R U' R' U
BR = S' , R' U' R U
RF = R' D R D' , S
RB = R D R' D' , S
UF = R F R' , S
DF = R F' R' , S
LF = R F2 R' , S
FU = S' , R' F R
FD = S' , R' F' R
FL = S' , R' F2 R
UB = R' B' R , S
DB = R' B R , S
LB = R' B2 R , S
BU = S' , R B' R'
BD = S' , R B R'
BL = S' , R B2 R'

Some cases have other decent alternatives, and there are also better algorithms for a few cases if you allow grip shifts (most notably if you allow E-moves), but I just thought this was a fun idea, and that the execution would look pretty cool

I’ve actually been planning on learning UR-3style so I might learn this in the meantime

 

[Aergyl]

That’s an interesting variant of the Orozco method you’ve described. It seems like you have put a lot of thought into optimizing finger placement and minimizing reg rips. The algorithms you’ve provided in commutator notation look well-designed for this specific approach. Keep up the good work!

Thank you

 

[Aergyl]

I’ve actually been planning on learning UR-3style so I might learn this in the meantime

Nice! I've been thinking about doing that as well.

 

[Silky]

This is a variant of Orozco for edges with no regrips and no grip shifts, using UR as buffer and RD as helper. More precisely, the left thumb and middle finger always stays on the center of the F face and the B face, and the right thumb and middle finger always stays on the FR and the BR sticker (except when double flicking). Here are the algorithms written in commutator notation:

RD = (do nothing)
DR = S' , U R' F U' R
UL = R U' : F , R' S R
LD = R' D : R S' R' , F'
LU = D' : R' F' R , S
DL = U : S' , R F R'
FR = S' , R U' R' U
BR = S' , R' U' R U
RF = R' D R D' , S
RB = R D R' D' , S
UF = R F R' , S
DF = R F' R' , S
LF = R F2 R' , S
FU = S' , R' F R
FD = S' , R' F' R
FL = S' , R' F2 R
UB = R' B' R , S
DB = R' B R , S
LB = R' B2 R , S
BU = S' , R B' R'
BD = S' , R B R'
BL = S' , R B2 R'

Some cases have other decent alternatives, and there are also better algorithms for a few cases if you allow grip shifts (most notably if you allow E-moves), but I just thought this was a fun idea, and that the execution would look pretty cool

Great stuff as always! Some of your Orozco corner targets are wrong ( BUR is listed twice, etc ). I've already learned Orozco with UF/UR and currently am using Eka. I'm curious which buffer/helper combo would be best for Eka. We'd have to figure out the best balance of setup moves and 3-cycle algs. UF/UR is mostly <R, S, E, D> when setting up to UR.

 

[abunickabhi]

This is a variant of Orozco for edges with no regrips and no grip shifts, using UR as buffer and RD as helper. More precisely, the left thumb and middle finger always stays on the center of the F face and the B face, and the right thumb and middle finger always stays on the FR and the BR sticker (except when double flicking). Here are the algorithms written in commutator notation:

RD = (do nothing)
DR = S' , U R' F U' R
UL = R U' : F , R' S R
LD = R' D : R S' R' , F'
LU = D' : R' F' R , S
DL = U : S' , R F R'
FR = S' , R U' R' U
BR = S' , R' U' R U
RF = R' D R D' , S
RB = R D R' D' , S
UF = R F R' , S
DF = R F' R' , S
LF = R F2 R' , S
FU = S' , R' F R
FD = S' , R' F' R
FL = S' , R' F2 R
UB = R' B' R , S
DB = R' B R , S
LB = R' B2 R , S
BU = S' , R B' R'
BD = S' , R B R'
BL = S' , R B2 R'

Some cases have other decent alternatives, and there are also better algorithms for a few cases if you allow grip shifts (most notably if you allow E-moves), but I just thought this was a fun idea, and that the execution would look pretty cool

Nice modification to the current Orozco method documented.

Do you want to video document the cases as well?

 

[adiwastu]

Have you considered the inverse for parity alg? It's quite nice and can be broken like (fat sledge) ( U sexy) (fix centers with S) (insert pair)

Really nice sets btw!!

 

[Aergyl]

Have you considered the inverse for parity alg? It's quite nice and can be broken like (fat sledge) ( U sexy) (fix centers with S) (insert pair)

Really nice sets btw!!

Thanks! I personally prefer the one I wrote, but the inverse looks just as good.

 

[Aergyl]

Nice modification to the current Orozco method documented.

Do you want to video document the cases as well?

I haven't really thought about doing that, but I might do it in the future. If anyone else wants to do it, feel free to do it though