The New Method / Substep / Concept Idea Thread

[dudefaceguy]

Anybody here know of alternative 2-look CMLL methods? I've refined the permutation-first Petrus variant that I posted a few weeks ago. Here's a new flowchart:

https://imgur.com/a/1O19Ytb

I can't find anything else besides orient-first methods that use 9 algorithms. I don't care if the other methods are good or fast - I just want to know if they exist because I'm a nerd.

 

[WoowyBaby]

Anybody here know of alternative 2-look CMLL methods? I've refined the permutation-first Petrus variant that I posted a few weeks ago. Here's a new flowchart:

https://imgur.com/a/1O19Ytb

I can't find anything else besides orient-first methods that use 9 algorithms. I don't care if the other methods are good or fast - I just want to know if they exist because I'm a nerd.

2-look CMLL methods include:
-Orient -> Permute (9 algs), most popular and by far the fastest
-Permute -> Orient (9 algs), using R’ D’ R D instead of algs makes a nice beginner method
-?????
-None other?
-I could think of one like Two Corners -> Other Two Corners (~5-10 algs) but it probably has no use

There’s a lot less options for 2-look CMLL, then say, L5Corners ( CMLL + last slot corner), which you can easily manipulate pieces with R U R’ or stuff like that.
So basically orient-permute and permute-orient are your only options for 2-look CMLL, sadly

 

[Imam Alam]

Anybody here know of alternative 2-look CMLL methods?

(stuff)

I don't care if the other methods are good or fast - I just want to know if they exist because I'm a nerd.

(stuff)

So basically orient-permute and permute-orient are your only options for 2-look CMLL, sadly

or maybe you can solve corners directly?

- with a repeated trigger and its mirror and inverse (8355 style), although this is not very efficient

- with two corner 3-cycles (Heise style), but this may have parity since edges are not solved yet (could someone please confirm this parity? does it require something like an N-perm in some cases as I suspect?)

 

[Cubingcubecuber]

I came up with a new last layer subset. In it you orient the edges and permute the corners with one alg. I call it KALL. In a solve you get F2L -1, Winter Variation, KALL, and EPLL. It is similar to COLL, but it only has 15 algs compared to COLL’s 42. I might use it in my speedsolves as an alternative to OLL/PLL or COLL/EPLL. I hope that some of you will find this subset useful

 

[ImmolatedMarmoset]

I came up with a new last layer subset. In it you orient the edges and permute the corners with one alg. I call it KALL. In a solve you get F2L -1, Winter Variation, KALL, and EPLL. It is similar to COLL, but it only has 15 algs compared to COLL’s 42. I might use it in my speedsolves as an alternative to OLL/PLL or COLL/EPLL. I hope that some of you will find this subset useful

The main problem I see with this is that it’s redundant. WV usually is used when your edges are already all oriented, and you do EO after WV. Why don’t you just do EOF2L-1, COLL, and EPLL? That’s 3 steps compared to your 2 steps, and honestly not too many more algs once you factor in WV (27 algs). Well, you might say, hey, why don’t I just mix WV and KALL together? Well that’s called OLLCP, and it’s kinda useful, but not quite as good I think for recog as ZBLL (correct me if I’m wrong). Decent idea, and although it is fewer algs to learn, I don’t think it’s faster and COLLs tend to be really fast anyway.

Oh right. I use roux. Why am I even arguing?

 

[WoowyBaby]

Faster than CFOP method:

1. 2x2x2 Block
2. Finish Cross
3. Last Three F2L Pairs
4. Normal OLL + PLL
(If you really want the quickest CFOP variant you'd end with ZBLS & ZBLL but it's a lot of effort to learn and maintain so that's why many people don't)

I have literally proven this to be better with real solves*. You might be able to say this is worse in theory, but not in practice.

- Lookahead is easier because pieces aren't trapped in the back, you can literally see every piece when 2x2x2 is solved.
- Average movecount is lower, 2x2x2 is 6 and Finish Cross is 5, (11 total), while Cross is 6.5? and 1st Pair is 7? (13.5 total) although I'm not sure so don't call me disingenuous or whatever.
- Ergonomics are arguably the same.
- Lookahead is doubley ahead because Finish Cross doesn't use that much brainpower meaning you can really see what your next pair will be.
- Transitioning to this / Learning this is pretty easy because only the beginning differs from normal CFOP, just practice building 2x2 Blocks and you'll be good.

If you can already plan Cross + 1 in inspection then this might not really benefit you, and doing this every single time might not be smart so "only" do it most of the time. *If you have difficult blocks or an easy cross, do normal CFOP.

Example, Scramble: U2 B2 D2 U R2 D F2 R2 F2 L' U2 B' U' B2 F' U R' F L'
(x2)
U' F L2 F2 L // 2x2x2 Block (5 moves)
R2 F' U' F2 R2 // Finish Cross (5 moves)
D R' U' R D' // Pair
U' L' U2 L R' U' R // Pair
F U F' // Pair
R2 D R' U R D' R2 F' U F R U' R' // LL
- Rotationless and still awesome

Try it out! What is your experience with this?

 

[ImmolatedMarmoset]

Faster than CFOP method:

1. 2x2x2 Block
2. Finish Cross
3. Last Three F2L Pairs
4. Normal OLL + PLL
(If you really want the quickest CFOP variant you'd end with ZBLS & ZBLL but it's a lot of effort to learn and maintain so that's why many people don't)

I have literally proven this to be better with real solves. You might be able to say this is worse in theory, but not in practice.

- Lookahead is easier because pieces aren't trapped in the back, you can literally see every piece when 2x2x2 is solved.
- Average movecount is lower, 2x2x2 is 6 and Finish Cross is 5, (11 total), while Cross is 6.5? and 1st Pair is 7? (13.5 total) although I'm not sure so don't call me disingenuous or whatever.
- Ergonomics are arguably the same.
- Lookahead is doubley ahead because Finish Cross doesn't use that much brainpower meaning you can really see what your next pair will be.
- Transitioning to this / Learning this is pretty easy because only the beginning differs from normal CFOP, just practice building 2x2 Blocks and you'll be good.

If you can already plan Cross + 1 in inspection then this might not really benefit you, and doing this everytime might not be smart so "only" do it most of the time.

Example, Scramble: U2 B2 D2 U R2 D F2 R2 F2 L' U2 B' U' B2 F' U R' F L'
(x2)
U' F L2 F2 L // 2x2x2 Block (5 moves)
R2 F' U' F2 R2 // Finish Cross (5 moves)
D R' U' R D' // Pair
U' L' U2 L R' U' R // Pair
F U F' // Pair
R2 D R' U R D' R2 F' U F R U' R' // LL
- Rotationless and still awesome

Try it out! What is your experience with this?

I’m sure it’s faster, and I will do a few solves, but come on Woowy Baby! That’s normal stuff! We expect more from you! At least have like an EO2x2x2 in there somewhere lol (JK about all this)

But no seriously this looks pretty cool. Some ideas from my method tinkering mind: 2x2x2 in the back left, then EO (you could mix the first two), then finish cross (you could also mix steps 2 and 3), then f2l, then ll with cross solved.

 

[Sue Doenim]

Faster than CFOP method:

1. 2x2x2 Block
2. Finish Cross
3. Last Three F2L Pairs
4. Normal OLL + PLL
(If you really want the quickest CFOP variant you'd end with ZBLS & ZBLL but it's a lot of effort to learn and maintain so that's why many people don't)

I have literally proven this to be better with real solves. You might be able to say this is worse in theory, but not in practice.

- Lookahead is easier because pieces aren't trapped in the back, you can literally see every piece when 2x2x2 is solved.
- Average movecount is lower, 2x2x2 is 6 and Finish Cross is 5, (11 total), while Cross is 6.5? and 1st Pair is 7? (13.5 total) although I'm not sure so don't call me disingenuous or whatever.
- Ergonomics are arguably the same.
- Lookahead is doubley ahead because Finish Cross doesn't use that much brainpower meaning you can really see what your next pair will be.
- Transitioning to this / Learning this is pretty easy because only the beginning differs from normal CFOP, just practice building 2x2 Blocks and you'll be good.

If you can already plan Cross + 1 in inspection then this might not really benefit you, and doing this everytime might not be smart so "only" do it most of the time.

Example, Scramble: U2 B2 D2 U R2 D F2 R2 F2 L' U2 B' U' B2 F' U R' F L'
(x2)
U' F L2 F2 L // 2x2x2 Block (5 moves)
R2 F' U' F2 R2 // Finish Cross (5 moves)
D R' U' R D' // Pair
U' L' U2 L R' U' R // Pair
F U F' // Pair
R2 D R' U R D' R2 F' U F R U' R' // LL
- Rotationless and still awesome

Try it out! What is your experience with this?

The problem I see with this is that it's literally just forcing XCross. If there is a nice case for this, an advanced CFOP solver will use it, but if there's not, they won't. I imagine that in the cases that it's not nice, regular CFOP would be faster, and an advanced CFOP solver will solve it as such.

 

[WoowyBaby]

The problem I see with this is that it's literally just forcing XCross. If there is a nice case for this, an advanced CFOP solver will use it, but if there's not, they won't. I imagine that in the cases that it's not nice, regular CFOP would be faster, and an advanced CFOP solver will solve it as such.

Right right. I said in my post to only use it most of time, because of course, if you have an easy cross or difficult blocks then use standard CFOP.
My conclusion is people should be neutral-ish between this start and normal CFOP.

On a side note, this also reminds me of Jayden McNeill’s video on Option Select, and it’s not smart to do the same thing all the time, so he said doing ZBLS&ZBLL is the best as your primary system of LSLL (aka it is the fastest single method) but if you have an easy case from another set you’d want to know that too

“Just forcing XCross”? False, lookahead differs.

I’m sure it’s faster, and I will do a few solves, but come on Woowy Baby! That’s normal stuff! We expect more from you! At least have like an EO2x2x2 in there somewhere lol (JK about all this)

But no seriously this looks pretty cool. Some ideas from my method tinkering mind: 2x2x2 in the back left, then EO (you could mix the first two), then finish cross (you could also mix steps 2 and 3), then f2l, then ll with cross solved.

Yes EO2x2x2 how could I forget xD

I’ll think about it!
2x2x2, EOCross, 3 F2L Pairs, LL. Ok.
My thoughts are that EO recognition is too slow, so this could only be faster if you predict atleast some of your EO in inspection, BUT, I will test this out before putting your idea down, because F2L w/ EO is in fact slightly better and the option of doing ZBLL for 1 look last layer is much better than 2LLL. Of course I don’t know full ZBLL and I might not know the tricks you can do with EO-done F2L, but I’ll get back to you after I test this a little, I do think it has potentional!

 

[Cubingcubecuber]

The main problem I see with this is that it’s redundant. WV usually is used when your edges are already all oriented, and you do EO after WV. Why don’t you just do EOF2L-1, COLL, and EPLL? That’s 3 steps compared to your 2 steps, and honestly not too many more algs once you factor in WV (27 algs). Well, you might say, hey, why don’t I just mix WV and KALL together? Well that’s called OLLCP, and it’s kinda useful, but not quite as good I think for recog as ZBLL (correct me if I’m wrong). Decent idea, and although it is fewer algs to learn, I don’t think it’s faster and COLLs tend to be really fast anyway.

Oh right. I use roux. Why am I even arguing?

I created this method as a fewer algorithm easy to learn last layer subset. WV is really easy to learn; you can learn it in a day. If you still don’t want to learn WV, than you can do CO after F2L. KALL is easy to recognize; I think easier than COLL. I have experience with COLL, because I used it for a long time. I think your idea about EOF2L is good, but EO recognition is deadly(I used to use ZZ). You might be able to use this in Roux as a subset of CMLLEO(I know Kian doesn’t like it). Btw, 5 of the 15 algs you probably already know - Jb perm, Y perm, OLL 20, OLL 28, and OLL 57, so 10 algs for a ll subset is pretty low. Thank you for your feedback, it is appreciated.

 

[PapaSmurf]

I came up with a new last layer subset. In it you orient the edges and permute the corners with one alg. I call it KALL. In a solve you get F2L -1, Winter Variation, KALL, and EPLL. It is similar to COLL, but it only has 15 algs compared to COLL’s 42. I might use it in my speedsolves as an alternative to OLL/PLL or COLL/EPLL. I hope that some of you will find this subset useful

The biggest problem with this: it's bad. If you wanna do it from every slot, it is 27*4=108 algs for just WV alone, and the algs for WV aren't great for even FR. You also do 4 looks: make the pair, insert the pair+WV, KALL, EPLL compared to 3 for solve pair, OLL, PLL, which is also less algs for slot neutrality. I just don't see how this is worth it. Yeah, if you skip CO, this is probably worth it, but otherwise don't main it. If you really want a low alg count 2 look last layer, ZZ-R is the lowest by far without something complex (such as CP).

Faster than CFOP method:

1. 2x2x2 Block
2. Finish Cross
3. Last Three F2L Pairs
4. Normal OLL + PLL
(If you really want the quickest CFOP variant you'd end with ZBLS & ZBLL but it's a lot of effort to learn and maintain so that's why many people don't)

I have literally proven this to be better with real solves*. You might be able to say this is worse in theory, but not in practice.

- Lookahead is easier because pieces aren't trapped in the back, you can literally see every piece when 2x2x2 is solved.
- Average movecount is lower, 2x2x2 is 6 and Finish Cross is 5, (11 total), while Cross is 6.5? and 1st Pair is 7? (13.5 total) although I'm not sure so don't call me disingenuous or whatever.
- Ergonomics are arguably the same.
- Lookahead is doubley ahead because Finish Cross doesn't use that much brainpower meaning you can really see what your next pair will be.
- Transitioning to this / Learning this is pretty easy because only the beginning differs from normal CFOP, just practice building 2x2 Blocks and you'll be good.

If you can already plan Cross + 1 in inspection then this might not really benefit you, and doing this every single time might not be smart so "only" do it most of the time. *If you have difficult blocks or an easy cross, do normal CFOP.

Example, Scramble: U2 B2 D2 U R2 D F2 R2 F2 L' U2 B' U' B2 F' U R' F L'
(x2)
U' F L2 F2 L // 2x2x2 Block (5 moves)
R2 F' U' F2 R2 // Finish Cross (5 moves)
D R' U' R D' // Pair
U' L' U2 L R' U' R // Pair
F U F' // Pair
R2 D R' U R D' R2 F' U F R U' R' // LL
- Rotationless and still awesome

Try it out! What is your experience with this?

This is literally CFOP with XCross. So yes, it's good, but not new. And on the 2x2x2 then EO thing, that is also a thing that people are working on (although it's more EOCross/EOLine/EOArrow(3/4Cross) +1 pair.

 

[ImmolatedMarmoset]

The biggest problem with this: it's bad. If you wanna do it from every slot, it is 27*4=108 algs for just WV alone, and the algs for WV aren't great for even FR. You also do 4 looks: make the pair, insert the pair+WV, KALL, EPLL compared to 3 for solve pair, OLL, PLL, which is also less algs for slot neutrality. I just don't see how this is worth it. Yeah, if you skip CO, this is probably worth it, but otherwise don't main it. If you really want a low alg count 2 look last layer, ZZ-R is the lowest by far without something complex (such as CP).


This is literally CFOP with XCross. So yes, it's good, but not new. And on the 2x2x2 then EO thing, that is also a thing that people are working on (although it's more EOCross/EOLine/EOArrow(3/4Cross) +1 pair.

Yeah, I’m not surprised that it’s not new. I just hadn’t heard of it before, so I thought I’d propose it.

 

[Metallic Silver]

Skewb Method: Zim Method

1. Ranzha Block
2. Another Ranzha Block adjacently next to the 1st ranzha block
3. Align all centers correctly by 1 move.
4. (You can be lucky or unlucky.)
4a. Pure CLL (lucky)
4b. Permute all corners (idk algs)
5b. Orient all corners (idk algs)

or

1. Two Ranzha blocks opposite of each other
2. Last Layer


Skewb Method: Anti-Ranzha

1. Anti-Ranzha Block (Same as Ranzha block, but one of the center is the opposite color.)
2. Welder's Mask (to finish first layer)
3. Last Layer (Mostly 2-3 sledges)

 

[Cubingcubecuber]

Well, you might say, hey, why don’t I just mix WV and KALL together? Well that’s called OLLCP, and it’s kinda useful, but not quite as good I think for recognition as ZBLL (correct me if I’m wrong).

WV is while inserting the last slot, so it would not be OLLCP. It is a good idea, but it probably has a lot of cases to learn. It could be a good alternative to ZBLS/ZBLL, though.

The biggest problem with this: it's bad. If you wanna do it from every slot, it is 27*4=108 algs for just WV alone, and the algs for WV aren't great for even FR. You also do 4 looks: make the pair, insert the pair+WV, KALL, EPLL compared to 3 for solve pair, OLL, PLL, which is also less algs for slot neutrality. I just don't see how this is worth it. Yeah, if you skip CO, this is probably worth it, but otherwise don't main it. If you really want a low alg count 2 look last layer, ZZ-R is the lowest by far without something complex (such as CP).

This is not meant as a main method. It is meant to give you more options for your last layer. Also, coll has 4 looks; solve pair, VHLS, COLL, EPLL. You could do ZBLS, but couldn’t you do the same thing but orienting the corners instead? I understand this method is suboptimal for some cases, and I’m not saying to use this instead of OLL/COLL; I’m just proposing a low alg count subset. 7 of the algs are Y/J perm with a setup move/s. They are easy to learn, and fast to execute.

 

[ImmolatedMarmoset]

WV is while inserting the last slot, so it would not be OLLCP. It is a good idea, but it probably has a lot of cases to learn. It could be a good alternative to ZBLS/ZBLL, though.

My apologies about that, but still, KALL just seems unnecessary. Why would you learn that when you can learn COLL and not only have a better and more useful algset under your belt, but also have something that can be transferred over to say, 2x2 (and yes, I know some COLLs are crap for 2x2, but it still can be used, while KALL would not be useful). COLLs can be quite fast, and personally, while I think KALL has some potential, you would get yourself into a rut, being lazy about learning something like COLL because you have something that is kind of a replacement for it.

 

[PapaSmurf]

This is not meant as a main method. It is meant to give you more options for your last layer. Also, coll has 4 looks; solve pair, VHLS, COLL, EPLL. You could do ZBLS, but couldn’t you do the same thing but orienting the corners instead? I understand this method is suboptimal for some cases, and I’m not saying to use this instead of OLL/COLL; I’m just proposing a low alg count subset. 7 of the algs are Y/J perm with a setup move/s. They are easy to learn, and fast to execute.

When I say COLL, I mean the every 1/8 times it comes up. And there are better ways for a 4 look lsll: last slot, 2 look OLL, PLL, which is 31 algorithms and slot neutral.

 

[RadicalMacaroni]

You may wonder what LRBW stands for. Well it stands for:

Like Roux, But Worse

Because that's what this method is. It's like roux, but worse.

Steps:
1. Solve a "4" shape. Like this:

2. Solve the E slice.
3. Solve the last slot.
4. CMLL.
5. LSE.

 

[Skewbed]

I've thought about this before, it is pretty similar to hexagonal francisco.

I guess it should be called octagonal francisco due to the shape.

Could be better than Roux, it allows for different ways to solve corners after E slice: Commutators maybe.

 

[RadicalMacaroni]

it is pretty similar to hexagonal francisco.

That's where I got the idea, I saw hexagonal francisco and I thought "maybe this could be less of a meme if we removed the DB edge and did LSE instead

 

[dudefaceguy]

or maybe you can solve corners directly?

- with a repeated trigger and its mirror and inverse (8355 style), although this is not very efficient

- with two corner 3-cycles (Heise style), but this may have parity since edges are not solved yet (could someone please confirm this parity? does it require something like an N-perm in some cases as I suspect?)

I came up with a commutator-only CMLL method that I describe in my 4x4 method here:
https://www.speedsolving.com/threads/intuitive-4x4-method-with-parity-avoidance.73049/

It includes an explanation and solution for odd corner parity.