# The New Method / Substep / Concept Idea Thread

#### Cubing Forever

##### Member
Would the pairs be built like that during FB and SB? Such that one pair is at uFL and the other at uFR? Or is there something else not conveyed by the image?
It's a rare case. You can build them but it's a waste of movecount.

btw here's a method based on CFOP and belt that I thought of last night:

Scramble: R2 U B2 F2 U' F2 D B2 F2 D' B' D B L U L' B L' D2 U'
z2 U F2 U2 L U' L' U L F' L' F L' U L //xxxcross of oriented pieces
U R' U2 R U' R f' U' f //LS+EO
R' U' R U' R' U2 R //DR
U2 R2 U R2 U S U2 S' //separation
U' R2 D R2 D' R2 D R2 D' R2//permute corners
U M' U2 M U R2 U2 R2 U2 R2 //permute a few edges

You'll understand it if you watch the example solve. Maybe useful for FMC if your continuations after DR are pretty good.

#### AlgoCuber

##### Member
New effecient and rotationless F2L method

1. Solve 1-3 edges of a cross (I prefer 3)
2. Solve 3 second-layer edges
3. Insert 3 out of 4 first-layer corners using the unsolved second layer edge slot (D moves are recommended for rotationless)
4. Solve the fourth psuedo pair
5. Insert the final white edge

Possible optimizations
1. Do step 1 with some of step 2
2. You can do step 2 and 3 at the same time
3. Combine steps 4 and 5

Example here (Not very efficient because I haven't really developed it yet)

#### Athefre

##### Member

I added your algs to the ACMLL document and a credit section to the Info tab to show how others have contributed. I also went through each case for this alg set and generated additional ones for some. The tab can be found after the Spiral sets and is called L/R Flip Swap Front. Thanks so much for making this set!

#### tsmosher

##### Member
I wholeheartedly welcome any criticisms.

Since it is very hard to find resources and tutorials for the 42 Method, this is a variant of that method which I have created for myself.

It is, in most ways, a blatant copy of that method with attempts to improve EO/EP and to utilize existing alg sets (much in the spirit of the original 42 Method IMHO). With these improvements came changes that make this method far different in many ways from Roux or 42. I'm cool with that. (Personally, I believe it retains many of the innovative aspects from each of these methods.)

All credit to Shadowslice (and others like Athefre who have proposed the same idea) for the BT-redux recognition system.
Although it can be implemented with ~20 algs (using 2L OLL for orientation during step 3), the intermediate versions of this method require ~57 algs***.

As such, I hereby reserve the name "Heinz method" for this method if anyone uses it. (Heinz is a registered trademark of H.J. Heinz Company. All rights reserved.)

***Actually 61 and 62 algs respectively, but I couldn't think of any cool names involving these numbers, so we'll consider both of these numbers to be ~57.

For step 1 (below), I personally recommend LEOR style, but any method you can use to build a 2x2x3 will work.

I personally do not solve EO at this stage, but there is no reason that it couldn't be. (The remainder of the solve could easily be kept <RUM>.)

Options include:
• LEOR-style
1. Block-build FB (in DL)
2. Solve DF/DB
• Petrus-style
1. Block-build 2x2x2
2. Extend with 2x2x1
• Squall-style
1. Block-build 2x2x1
2. Extend with pair
3. Solve DF/DB
• X-style
1. Build X-Line/Arrow/Cross
2. Extend with square/pair
• Nautilus-style
1. Block-build FB (in DL)
2. Block-build 2x2x2 (in DBR)
• Mehta-style
1. Block-build FB (in D layer)
2. Extend by solving 2-3QB
• Etc...
• Second Square (2x2x1 Block)
1. Find oriented corner.
• Using the free R slice, find or create an oriented U-layer corner. As you complete this step, keep this oriented corner out of the way (e.g., above the left block) on the U layer; we will need it later.
2. Solve DR edge.

3. Form BR F2L pair.
• Connect the DBR corner and the BR edge to form an F2L pair.
4. Insert F2L pair into the BR slot.
• Any second-to-last-slot methods for orientation could be incorporated during insertion of this F2L pair. (Being inserted into BR, this is not ideal for most of these methods though.)

• Pre-L5C
1. Find oriented edge.
• Due to the state of the cube at this point, there will be (at least) one good edge that is NOT in a position that we have already solved (i.e., one that is not part of either of our blocks that we’ve constructed thus far).
2. Pair oriented corner with oriented edge.
• I told you we would need this later. Well, the time has come.
• As you pair these pieces, it is important that these pieces both remain correctly oriented!
3. Position oriented corner in UBR and oriented edge in UR (directly above the solved dBR square of your cube).

4. Perform an R move to prepare for the "last layer."

Finally, we arrive at the "last layer." (We are really solving last slot + last layer at once.)

This is where I feel that I have implemented some true improvements over the original method which allow you to:
• solve EO during the beginning of this step (only looking at the U-layer edges)
• use alg sets you already know (e.g., OLL, COLL), and
I have unabashedly used algs from WaterZZ L6EP for this final step. (Since algs for L5EP with the FR edge unsolved are few and far between.)
A huge thank you to whoever created these algs (efattah?) as there a lot of them. (I only needed 12 though.)

This option is for the solver who knows basic EOLL and full COLL.
(Obviously, CxLL-EO would work as well.)

1. Solve EO.

2. Position the bottom corner in UBL.

3. L5C

• Solve the remaining 5 corners using the BT-redux recognition system and the 42 algs from the CxLL subset(s) of your choice.
4. It is now necessary to AUF to the correct position and then “un-offset” the right square block using an R’ move.
• The easiest way to recognize the desired AUF position is by lining up the misoriented U-layer corner (i.e., the bottom corner) with the corner that is currently in the DFR position.
• After R’ from this position, all corners on the cube will be solved.
5. L5EP-FR
• Solve the remaining 5 edges (UF, UR, UL, UB, FR) using one of 16 algorithms. (Includes 4 EPLL algs.)
This option is for the solver who knows full OLL and is willing to learn 6 COLL algs (to be used situationally).

1. Orient the current “last layer.”
• This can be done in 1 step (e.g., full OLL) or 2 steps (e.g., EOLL + OCLL, etc.) or in any number of steps really...
2. Position the bottom corner in UBL.

3. Beginner’s L5C

• Solve the remaining 5 corners using the BT-redux recognition system (only oriented cases) and the 6 algs from the CxLL subset(s) of your choice.
4. It is now necessary to AUF to the correct position and then “un-offset” the right square block using an R’ move.
• The easiest way to recognize the desired AUF position is by lining up the misoriented U-layer corner (i.e., the bottom corner) with the corner that is currently in the DFR position.
• After R’ from this position, all corners on the cube will be solved.
5. L5EP-FR
• Solve the remaining 5 edges (UF, UR, UL, UB, FR) using one of 16 algorithms. (Includes 4 EPLL algs.)

I have a personal alg sheet that I use. If there is any interest, I will post it here.

Last edited:

#### PapaSmurf

##### Member
I'm sorry to say, but this has already been proposed multiple times (to clarify, the F2L bit is basically a form of FreeFOP and the LSLL bit has been proposed as a "42 for not Roux" at least a couple of times). It's definitely cool as a method, and I'm happy the WaterZZ L6EP algs are being put to use (I genned most of them, although not that set actually).

In terms of speedsolving, you're better off either using normal ZZ or CFOP (whatever takes your fancy), but for style points, this wins.

#### tsmosher

##### Member
I'm sorry to say, but this has already been proposed multiple times (to clarify, the F2L bit is basically a form of FreeFOP and the LSLL bit has been proposed as a "42 for not Roux" at least a couple of times). It's definitely cool as a method, and I'm happy the WaterZZ L6EP algs are being put to use (I genned most of them, although not that set actually).

In terms of speedsolving, you're better off either using normal ZZ or CFOP (whatever takes your fancy), but for style points, this wins.

Not surprising. I was confused as to the ergonomics/mechanics of 42 after watching and rewatching the tutorials dozens of times. When it finally clicked, I ran with it and developed the above. It is essentially Roux/42 except that you solve DF/DB in order to make EO/EP easier during the LL. (Nothing groundbreaking here.)

I will say that I think I prefer the above to either ZZ or CFOP.

ZZ- orienting edges at the beginning and then not screwing them up during F2L is an incredible challenge that limits the ways in which I can solve- Limits the algs I can use, the rotations I can perform- I've just never gotten past that. (Not even for the holy grail of a 1LLL- which I would never achieve since I am not willing to memorize a fraction of those algs.)

And CFOP- The cross is very restrictive to your allowed movements, and the whole solve ends up feeling very robotic. Having said that, I solve CFOP when I am going for speed, but I feel like that is more a matter of familiarity and comfort.

With the above method, my goal here was to have a block-building start, followed by easy/intuitive steps in the middle to gradually solve the cube (e.g., DF/DB, BR pair, etc.) in preparation for L5CP/L6CP. Keeping the alg counts "manageable" (less than CFOP proper) and keeping EO dead simple were both goals here that I think I achieved. (Originally started this method with the last step as LSE/L7E, and I like it much better this way. I can do LSE just fine, but add a 7th edge... and I tend to unsolve the cube pretty often.)

#### Athefre

##### Member
I wholeheartedly welcome any criticisms.

Since it is very hard to find resources and tutorials for the 42 Method, this is a variant of that method which I have created for myself.

It is, in most ways, a blatant copy of that method with attempts to improve EO/EP and to utilize existing alg sets (much in the spirit of the original 42 Method IMHO). With these improvements came changes that make this method far different in many ways from Roux or 42. I'm cool with that. (Personally, I believe it retains many of the innovative aspects from each of these methods.)

All credit to Shadowslice (and others like Athefre who have proposed the same idea) for the BT-redux recognition system.
Although it can be implemented with ~20 algs (using 2L OLL for orientation during step 3), the intermediate versions of this method require ~57 algs***.

As such, I hereby reserve the name "Heinz method" for this method if anyone uses it. (Heinz is a registered trademark of H.J. Heinz Company. All rights reserved.)

***Actually 61 and 62 algs respectively, but I couldn't think of any cool names involving these numbers, so we'll consider both of these numbers to be ~57.

For step 1 (below), I personally recommend LEOR style, but any method you can use to build a 2x2x3 will work.

I personally do not solve EO at this stage, but there is no reason that it couldn't be. (The remainder of the solve could easily be kept <RUM>.)

Options include:
• LEOR-style
1. Block-build FB (in DL)
2. Solve DF/DB
• Petrus-style
1. Block-build 2x2x2
2. Extend with 2x2x1
• Squall-style
1. Block-build 2x2x1
2. Extend with pair
3. Solve DF/DB
• X-style
1. Build X-Line/Arrow/Cross
2. Extend with square/pair
• Nautilus-style
1. Block-build FB (in DL)
2. Block-build 2x2x2 (in DBR)
• Mehta-style
1. Block-build FB (in D layer)
2. Extend by solving 2-3QB
• Etc...
• Second Square (2x2x1 Block)
1. Find oriented corner.
• Using the free R slice, find or create an oriented U-layer corner. As you complete this step, keep this oriented corner out of the way (e.g., above the left block) on the U layer; we will need it later.
2. Solve DR edge.

3. Form BR F2L pair.
• Connect the DBR corner and the BR edge to form an F2L pair.
4. Insert F2L pair into the BR slot.
• Any second-to-last-slot methods for orientation could be incorporated during insertion of this F2L pair. (Being inserted into BR, this is not ideal for most of these methods though.)

• Pre-L5C
1. Find oriented edge.
• Due to the state of the cube at this point, there will be (at least) one good edge that is NOT in a position that we have already solved (i.e., one that is not part of either of our blocks that we’ve constructed thus far).
2. Pair oriented corner with oriented edge.
• I told you we would need this later. Well, the time has come.
• As you pair these pieces, it is important that these pieces both remain correctly oriented!
3. Position oriented corner in UBR and oriented edge in UR (directly above the solved dBR square of your cube).

4. Perform an R move to prepare for the "last layer."

Finally, we arrive at the "last layer." (We are really solving last slot + last layer at once.)

This is where I feel that I have implemented some true improvements over the original method which allow you to:
• solve EO during the beginning of this step (only looking at the U-layer edges)
• use alg sets you already know (e.g., OLL, COLL), and
I have unabashedly used algs from WaterZZ L6EP for this final step. (Since algs for L5EP with the FR edge unsolved are few and far between.)
A huge thank you to whoever created these algs (efattah?) as there a lot of them. (I only needed 12 though.)

This option is for the solver who knows basic EOLL and full COLL.
(Obviously, CxLL-EO would work as well.)

1. Solve EO.

2. Position the bottom corner in UBL.

3. L5C

• Solve the remaining 5 corners using the BT-redux recognition system and the 42 algs from the CxLL subset(s) of your choice.
4. It is now necessary to AUF to the correct position and then “un-offset” the right square block using an R’ move.
• The easiest way to recognize the desired AUF position is by lining up the misoriented U-layer corner (i.e., the bottom corner) with the corner that is currently in the DFR position.
• After R’ from this position, all corners on the cube will be solved.
5. L5EP-FR
• Solve the remaining 5 edges (UF, UR, UL, UB, FR) using one of 16 algorithms. (Includes 4 EPLL algs.)
This option is for the solver who knows full OLL and is willing to learn 6 COLL algs (to be used situationally).

1. Orient the current “last layer.”
• This can be done in 1 step (e.g., full OLL) or 2 steps (e.g., EOLL + OCLL, etc.) or in any number of steps really...
2. Position the bottom corner in UBL.

3. Beginner’s L5C

• Solve the remaining 5 corners using the BT-redux recognition system (only oriented cases) and the 6 algs from the CxLL subset(s) of your choice.
4. It is now necessary to AUF to the correct position and then “un-offset” the right square block using an R’ move.
• The easiest way to recognize the desired AUF position is by lining up the misoriented U-layer corner (i.e., the bottom corner) with the corner that is currently in the DFR position.
• After R’ from this position, all corners on the cube will be solved.
5. L5EP-FR
• Solve the remaining 5 edges (UF, UR, UL, UB, FR) using one of 16 algorithms. (Includes 4 EPLL algs.)

I have a personal alg sheet that I use. If there is any interest, I will post it here.

As PapaSmurf said, not completely new. You can see this used in the Transformation variant of Nautilus that is on the website. A pair and also an additional edge can be used for the transformation. I think this is the most natural use of transformation in any method. It perfectly fits the blockbuilding and takes care of L5C and L5E at the same time. 42 is great, but L7E is awkward in several ways. I'm holding out hope that some magical solution is found for that. I've said a few times that I think 42 would be easier to manage if a pair is used for the transformation instead of just an oriented corner. This way there is no L7E.

As for just using a pair in F2L-1, as you have, I'm sure this has been proposed many times. But I'm not sure if a method has actually had this developed in that specific way. At least not in a way where the proposer was confident enough in the idea to put it on a site or the wiki with documents.

#### PapaSmurf

##### Member
I've always thought that for 42, you could do EO+any U edge then conjugated L6EP. Iirc, the movecount isn't negatively affected and you get a 2 look L7E.

#### tsmosher

##### Member
Looking through your original proposal around Transformation-based methods (which even at that time was not a new concept) is blowing my mind right now. For example, it seems obvious that I can proceed with any 1 of 4 possible F2L pairs from a 2x2x3 block; but even just extending that to any 1 of 8 possible squares (while it is something I've tried a couple times) is far more powerful...

Honestly, most of your methods soar right over my head and seem like some sort of black magic. Thanks for taking the time to reply to me as you have opened me up to a new (to me, at least) collection of concepts and methods. I will be looking into this earnestly but-- alas-- with my limited understanding, I'm not sure I'll innovate too much in this space. I'll probably spend the next week trying to understand the Nautilus Transformation method alone.

More to the point, why can't you use a U-layer pair (or something similar) for the transformation in 42? So that we don't get stuck with more edges to solve at the end?

Also, re: L7E, I think that Shadowslice's proposal of FR+EO (essentially L7EOP --> oriented L6E) sounded brilliant. But it seems that he dropped off the face of the planet with regards to this method and never created algs/tutorials/etc. for that step. With that step in place and fleshed out for the ignorant masses like myself, I would use 42 as is and be done with it.

Although 2opp EO would probably be more efficient, my head hurts just thinking about orienting/permuting 7 edges (whilst keeping track of corners so that I can reassemble them as well). By contrast, L7EOP seems more approachable and seems like a problem set that could be solved somewhat intuitively (much like L5EOP). Do you not agree here?

#### Athefre

##### Member
I've always thought that for 42, you could do EO+any U edge then conjugated L6EP. Iirc, the movecount isn't negatively affected and you get a 2 look L7E.

That could work. There is a big issue though. EO recognition is more difficult than in Roux. One solution to that is to track the FR edge during SB or the corner solving alg.

Looking through your original proposal around Transformation-based methods (which even at that time was not a new concept) is blowing my mind right now. For example, it seems obvious that I can proceed with any 1 of 4 possible F2L pairs from a 2x2x3 block; but even just extending that to any 1 of 8 possible squares (while it is something I've tried a couple times) is far more powerful...

Honestly, most of your methods soar right over my head and seem like some sort of black magic. Thanks for taking the time to reply to me as you have opened me up to a new (to me, at least) collection of concepts and methods. I will be looking into this earnestly but-- alas-- with my limited understanding, I'm not sure I'll innovate too much in this space. I'll probably spend the next week trying to understand the Nautilus Transformation method alone.

Transformation as a concept originated in NMLL and A2 from 2010-2012. Those were the first transformation-based methods. Even back then I was using the term "transformation". But it was only last year that I added the term to the wiki. I was the first to discover the concept. But Joseph Briggs definitely deserves a lot of credit for popularizing it with 42.

More to the point, why can't you use a U-layer pair (or something similar) for the transformation in 42? So that we don't get stuck with more edges to solve at the end?

Also, re: L7E, I think that Shadowslice's proposal of FR+EO (essentially L7EOP --> oriented L6E) sounded brilliant. But it seems that he dropped off the face of the planet with regards to this method and never created algs/tutorials/etc. for that step. With that step in place and fleshed out for the ignorant masses like myself, I would use 42 as is and be done with it.

Although 2opp EO would probably be more efficient, my head hurts just thinking about orienting/permuting 7 edges (whilst keeping track of corners so that I can reassemble them as well). By contrast, L7EOP seems more approachable and seems like a problem set that could be solved somewhat intuitively (much like L5EOP). Do you not agree here?

I think Jason Wong developed an FR+EO kind of thing for 42. 2opp EO definitely is difficult because EO is very difficult to recognize. It would be nice if there was a solution that doesn't involve EO of all seven edges. Using a pair for transformation kind of helps that, but still isn't perfect unless edge tracking is done.

#### AlgoCuber

##### Member
1 Look Line Last layer! (nicknamed 1LOL LOL LOL This is awesome)
This CFOP/ZZ/Petrus variant was inspired by brainstorming ways of restricting the last layer during F2L so that the amount of cases for a 1-look last layer dropped. This is the result of me and JTWong71's brainstorming.
The Idea is to have a solved 1x2x3 Line, with edges already oriented as in WV.
Some of the benefits is that 1/3 of the time you get a really easy PLL(U-perms, F-perm, J perms), and recognition is actually really good. There is also a 1/18 chance of skipping the last layer altogether, and 8 out of 18 times you get a really fast 2-gen case.

This variant comes in three parts:
-solve F2L-1 and eo
-solve 2 corner edge pairs
CE pair a:U Layer corner-edge pair and insert in slot(part of the solved line)
CE pair b:F2L corner-edge pair placed at BL
-F2L + L(aka LS+L) - 9 cases
-1LLL(1 Look Line Last Layer) - 18 cases(5 PLL, 1 solved)

The algorithms are grouped by the position of the final Line corner.(2/3 of the line is in the F2L slot). The F2L pair is at BL. The orientations are relative to the U layer, not the rest of the Line.

UFR:
Correct Orientation: (U) L' U2 R U' R' U2 L
Clockwise Twist: (U2) R' U2 R U R' U R2 U2 R'
Counterclockwise Twist: R U2 R'

UFL:
Correct Orientation: (U2) R2 D R' U R D' R2 U R U' R'
Clockwise Twist: (U2) R U R' F' U' F U R' F R F'
Counterclockwise Twist:

UBR:
Correct Orientation: (U2) R' F' R U2 R U2 R' F
Clockwise Twist: R U2 R D' R U' R' D R U R
Counterclockwise Twist: R2 D R' U2 R D' R2

corners oriented:
Just do one of your friendly PLL's. It will either be an F-perm, one of the U-perms, or a J-perm.

(Note: LL Line is placed at UL)
2GLL:

T-Set:
Pure Flip: R' U R U2 R' U2 R' U' R U' R' U2 R U2 R
Clockwise U-Perm: (U2) R U2 R U' R2 U' R U R2 U2 R2 U' R U' R
Counterclockwise U-Perm: (U2) R U R' U R U2 R' U' R U2 R' U' R U' R'

U-Set:
Pure Flip: (U) R U2 R' U' R U' R' U2 R' U2 R U R' U R
Clockwise U-Perm: (U2) R' U' R U R' U R U2 R' U R U2 R' U' R
Counterclockwise U-Perm: (U2) R U R' U' R U' R' U2 R U' R' U2 R U R'

Corner Swap:

T-Set:
F-Perm: F D R' U R U' D' R U F R F' U' R' F'
Ja-Perm (Edge Swap: UB + UR): R2 F' R2 U' R' F' U' F R U R' F R
Jb-Perm (Edge Swap: UF + UR): F R D' R2 D R D' R D F' U' R' U R

U-Set:
F-Perm: F U' R U R' F R' F' R2 U' R' F' U' F U F'
Ja-Perm (Edge Swap: UB + UR): (U') R U' R2 F2 D' F' D F' R U R' F R F'
Jb-Perm (Edge Swap: UF + UR): x' U' R U R' F R U' R' U2 F' U' F R' F' R F'
for the first pair, pair up a corner and an edge in the U-layer(make sure they can fit in the slot)
for the second pair, intuitively solve the final CE pair so it preserves the first corner-edge pair(may take some practice). If possible, track the Final Line corner during this step.
Can anyone show me an example solve of this method? I can't seem to understand it very well

#### Platform_

##### Member
I correct my guide by methodd of LL Platform.
I writed this in Italian my language.

#### Attachments

• GUIDA DEL METODO PLATFORM.pdf
386.9 KB · Views: 8

#### trangium

##### Member
Here's an idea for a beginner's blindfolded method. This probably won't be good for everyone, but could be okay for those who have trouble remembering their setup moves.
It works similarly to Old Pochmann, except with different swap algs. In particular, the edges swap alg swaps 2 edges and 4 centers, which allows for more freedom in setups, leading to shorter setups. The different corner alg allows parity to be handled in a simple way.

Speffz lettering is used here.

Edges Buffer: S
Edges Target: C
Allowed setups: <U, R, F, L>
Edge swap alg: M' U' M' U M' U M' U2 M' U M' U M' U' or U2 M’ U’ S R’ F’ R S’ R’ F R U’
Parity: Add R to the end of edge memo
Special case: if there are an odd number of edge letter pairs, add E2 M’ E2 M to the start of execution

Corner buffer: H
Corner Target: C
Allowed setups: <U, R, F>
Corner swap alg: R B R’ U2 r U’ r B r2 U2

U' D B R' B U' D2 F' L2 D B2 L2 U' F2 L2 U D2 L2 F2 R

Edges: GU IV QP DF HN EB MR (Add R because there is parity)
Corners: BI UJ EW V

E2 M' E2 M // Odd number of edge letter pairs (7 is odd)
L' F (M' U' M' U M' U M' U2 M' U M' U M' U') F' L // G
F2 (M' U' M' U M' U M' U2 M' U M' U M' U') F2 // U
F R U (M' U' M' U M' U M' U2 M' U M' U M' U') U' R' F' // I
R2 U (M' U' M' U M' U M' U2 M' U M' U M' U') U' R2 // V
U R' F' (M' U' M' U M' U M' U2 M' U M' U M' U') F R U' // Q
F' (M' U' M' U M' U M' U2 M' U M' U M' U') F // P
U' (M' U' M' U M' U M' U2 M' U M' U M' U') U // D
F (M' U' M' U M' U M' U2 M' U M' U M' U') F' // F
L2 F (M' U' M' U M' U M' U2 M' U M' U M' U') F' L2 // H
R2 F' (M' U' M' U M' U M' U2 M' U M' U M' U') F R2 // N
L F (M' U' M' U M' U M' U2 M' U M' U M' U') F' L' // E
U (M' U' M' U M' U M' U2 M' U M' U M' U') U' // B
R' F' (M' U' M' U M' U M' U2 M' U M' U M' U') F R // M
L U' (M' U' M' U M' U M' U2 M' U M' U M' U') U L' // R

U (R B R' U2 r U' r B r2 U2) U' // B
F2 R (R B R' U2 r U' r B r2 U2) R' F2 // I
F2 (R B R' U2 r U' r B r2 U2) F2 // U
F R (R B R' U2 r U' r B r2 U2) R' F' // J
U R' (R B R' U2 r U' r B r2 U2) R U' // E
R2 (R B R' U2 r U' r B r2 U2) R2 // W
R2 U (R B R' U2 r U' r B r2 U2) U' R2 // V

View at alg.cubing.net

Last edited:

#### PapaSmurf

##### Member
That's pretty cool, (although potentially kinda hard to visualise for beginners). The first edge alg needs a bit of reworking, but otherwise I actually really like it. The main disadvantage is that M2/M are both better and are also suitable for beginners, which is kinda annoying, but hey.

#### MethodNeutral

##### Member
Just had this thought this morning and wanted to see if this has been thought of before, I tried looking on the speedsolving wiki but I couldn't find anything for it.

Essentially my idea is EJLS (link) but for full OLL. The idea is when solving F2L in CFOP, if a pair happens to be in the correct slot and the edge is flipped correctly (but the corner is twisted), then simply continue solving F2L. Then execute one of ~116 (?) algs which untwists the corner and orients the last layer.

The 116 number looks a bit daunting, but half of them would be mirrors since the corner can be twisted one of two ways. So it'd really be about 58 algs, but that's just my own guess for the number of cases.

Another interesting idea could be to learn the algs which solve OLL while correcting an F2L pair with a flipped edge.

I should clarify, both of these should be considered as alg sets which are not meant to be used in every solve. Like COLL in the context of CFOP, this isn't something a solver should go out of their way to use, but if the opportunity presents itself (e.g. a pre-made pseudo-pair), then it would come in handy to have these algorithms.

#### AlgoCuber

##### Member
Theses have most likely been proposed before but here are my ideas for skewb:

Intermediate:
First face
EG + A center
L5C

First face
EG
L6C

3 face corners
Last 5 corners
L6C

#### Z1hc

##### Member
I have some 2x2 methods that may be new. Here they are:
2x2 method 1:
Step1: create a layer except don’t solve the last piece (Down Front Right corner.).
Step 2: solve the front right up corner.
Step 3: permute the last 4 corners so they look like 4 corner twists (or less).
Step 4: solve the 4 twisted (or less) corners with one algorithm.

2x2 method 2:
First solve down left front and down left back corner.
Step 2: solve up right front and up right back corner.
Step 3: permute the last 4 corners.
step 4: orient the last 4 corners.
/\ the last 2 steps can be rearranged and might be easier that way.

#### Jamal_69

##### Member
hey! so I've had this idea for a while now so here goes! I essentially wanted to create an actually viable way of doing roux on megaminx and I think I've found it... sorta. this may have been proposed before Idk. this method is sort of a variant of balínt I guess and also I'm kinda stuck on how to do step 5 so some help would be appreciated
step 1: F2L. just like with most megaminx methods you start off with the first two layers. you can do this however you want but I do it by blockbuilding since I'm a roux user.
step 2: first block. the first block is made up of a balínt block and the two pairs adjacent to it. nothing much more to say here.
step 3: second block. same thing as first block. make sure there's a balínt block slot in the front between the first and second block and two balínt block slots and a pair slot in the back in between them.
step 4: solve the two balínt blocks in the back. very straight forward. by the end of this step there will be one s2l slot and one balínt block slot left of the s2l.
step 5: roux style EO. this is the step I'm having trouble on so I would love some help on it. it's basically doing roux style EO with R' L F' L' R I know what the move does but can't figure out recognition for it. ZZ-Spike recognition doesn't work for this method as far as I know.
step 6: finish s2l. last balínt block slot and s2l slot
step 7: last layer. just like ZZ-Spike since all edges are oriented. so that's the method. I hope somebody can find a way to do EO.

#### Waffles

##### Member
I don’t know if anyone has ever thought of this idea before (they probably have) and I’m not here to think about optimisation. I know it’s unlikely anyone will use it, and even if they do, they will notice some flaws in the method.

Anyway, it’s a substep of CFOP (my main method) where you do 3 piece cross, then leave the final piece unsolved. Then you do F2L having the final piece of the cross unsolved so you can do M moves to make F2L slightly easier. Then you can do some kind of edge orientation/solving the last cross piece as 1st look OLL, then COLL and the final edges.

Now, this is assuming you know COLL and would have to learn a few algorithms (which I can’t be bothered to make them).

Potential Problems: if you use a lot of ZB or WV or other last-slot related things. Obviously this would rely on having good M’/M fingertricks and being good at turning in general. It might be hard to recognise LCEO algorithms depending on the case. I assume there won’t be many algorithms for it.

As you can tell, this was quite rushed and I haven’t tested out or anything and no-one is going to use it but I just thought I’d put it out there anyway.

Steps:
3Cross
MF2L
LCEO
COLL
PLL

I hope this inspired you in some way

#### zzoomer

##### Member
I don’t know if anyone has ever thought of this idea before (they probably have) and I’m not here to think about optimisation. I know it’s unlikely anyone will use it, and even if they do, they will notice some flaws in the method.

Anyway, it’s a substep of CFOP (my main method) where you do 3 piece cross, then leave the final piece unsolved. Then you do F2L having the final piece of the cross unsolved so you can do M moves to make F2L slightly easier. Then you can do some kind of edge orientation/solving the last cross piece as 1st look OLL, then COLL and the final edges.

Now, this is assuming you know COLL and would have to learn a few algorithms (which I can’t be bothered to make them).

Potential Problems: if you use a lot of ZB or WV or other last-slot related things. Obviously this would rely on having good M’/M fingertricks and being good at turning in general. It might be hard to recognise LCEO algorithms depending on the case. I assume there won’t be many algorithms for it.

As you can tell, this was quite rushed and I haven’t tested out or anything and no-one is going to use it but I just thought I’d put it out there anyway.

Steps:
3Cross
MF2L
LCEO
COLL
PLL

I hope this inspired you in some way
This is just a worse version of Hawaiian Kociemba. It's worse because in Hawaiian Kociemba you orient F2L edges to make the rest of the solve more efficient and easier.

Last edited: