The New Method / Substep / Concept Idea Thread

[OtaMota]

Whatever method this is.

Spoiler: DISCLAIMER: DO NOT WATCH RECON IF PRONE TO SEIZURES

 Twizzle link 

 Setup 

R2 U F2 U B2 U R2 U2 B2 D' L2 U2 R U R' F' R' B2 L2 R2

 Moves 

y256 U y256 L y256 F' y256 R y256 L2 y2' F' y256 U y256 L y256 F' y256 L' y256 U y256 R' y256 y' R' y256 F' y256 R y256 U y256 R y256 U' y256 R' y256 F y256 y' L y256 U' y256 L' y256 U y256 L' y256 U' y256 L y256 r y256 U y256 r' y256 U' y256 r' y256 F y256 r y256 F' y256 U2 y256 y' L' y256 U y256 L y256 U' y256 L' y256 U y256 L y256 U2' y256 R y256 U y256 R' y256 U y256 R y256 U' y256 R' y256 U' y256 R' y256 F y256 R y256 F' y256 U2 y256 R' y256 U' y256 F' y256 R y256 U y256 R' y256 U' y256 R' y256 F y256 R2 y256 U' y256 R' y256 U' y256 R y256 U y256 R' y256 U y256 R y256 U' y256

I opened the twizzle and set the playback to 6x. I experienced… something

 

[DoAnKhang]

alg.cubing.net

alg.cubing.net

my ribbon method mod but im to lazy to do the last part

that is just Nautilus https://sites.google.com/view/nautilus-method/

 

[StarStarSpace]

Hi, is this method already existing (Maybe it’s just a sub-method of Roux. I tried to find a way to avoid CMLL intuitively.)?:

CMLL-Skip-Method (Proposer: StarStarSpace, 2024)
or
1/162-Method (because in one out of 162 solves you could’ve just done Roux with a CMLL-Skip)

Steps (42 – 55 moves approximately):
1. CPFB: solving corner permuted FB with any method you want. Here are two possibilities a and b:
a. CPLine + FBExtension (10 – 13 moves)
i. CPLine: create a 1x1x3 block in the bottom left, while permuting the corners (4 – 5 moves)
ii. FBExtension: extend the CPLine to a 1x2x3 block, like in Roux, using <r,u,R,U> (6 – 8 moves)
b. FB + CP (11 moves on avg)
i. FB: creating a 1x2x3 block in the bottom left, just like in Roux (on avg 6 moves, if you’re x2y neutral)
ii. CP: permute the corners, using triggers like F R F’ or F’ U’ F (mirrored on the B-side) (5 or less moves (0 – 2 commutator moves plus one trigger))

2. 6CO: orient the last 6 corners (6 moves on avg)
a. Intuitive approach: Try to memorize a few cases, where you can orient all corners in 3 or less moves, so you can try to go to these cases from every other case.
b. Algorithmic approach: I am still working on it!

3. SB: Solve the 1x2x3 block in the bottom right intuitively without breaking the FB (CP) or misorienting the corners. Use commutators like in the Corners First method to insert the SB edges. (approximately 15 – 20 moves)
a. Just pair up the DR corners and insert all the three remaining edges using commutators.
b. But maybe it’s easier to build the SBLine (the 1x1x3 block, that needs to go in the bottom right) on the U-Layer at first. After that you can insert the other to SB edges, like in the 42-Method.

4. CMLL-Skip! (Otherwise something went wrong in CP or CO) (0 moves)

5. LSE: Now you can finish your solve, just like in Roux. (13 moves on avg)

Example Solves (alg.cubing.net):
1st example (smallest substeps explained)
2nd example
3rd example

I think, it's some mix from Roux, 42 and YruRU, but maybe 6CO is totally new? Please tell me, so I can write a wiki article in that case
Thank You!


---
edit 29.10.2025: fixed writing mistake (swapped "corners" and "edges" in 2a)
edit 30.10.2025: there are 162 cmll possibilities, not 161

 

[eeeeeeeee]

Hi, is this method already existing (Maybe it’s just a sub-method of Roux. I tried to find a way to avoid CMLL intuitively.)?:

CMLL-Skip-Method (Proposer: StarStarSpace, 2024)
or
1/161-Method (because in one out of 161 solves you could’ve just done Roux with a CMLL-Skip)

Steps (42 – 55 moves approximately):
1. CPFB: solving corner permuted FB with any method you want. Here are two possibilities a and b:
a. CPLine + FBExtension (10 – 13 moves)
i. CPLine: create a 1x1x3 block in the bottom left, while permuting the corners (4 – 5 moves)
ii. FBExtension: extend the CPLine to a 1x2x3 block, like in Roux, using <r,u,R,U> (6 – 8 moves)
b. FB + CP (11 moves on avg)
i. FB: creating a 1x2x3 block in the bottom left, just like in Roux (on avg 6 moves, if you’re x2y neutral)
ii. CP: permute the corners, using triggers like F R F’ or F’ U’ F (mirrored on the B-side) (5 or less moves (0 – 2 commutator moves plus one trigger))

2. 6CO: orient the last 6 corners (6 moves on avg)
a. Intuitive approach: Try to memorize a few cases, where you orient all edges in 3 or less moves, so you can try to go to these cases from every other case.
b. Algorithmic approach: I am still working on it!

3. SB: Solve the 1x2x3 block in the bottom right intuitively without breaking the FB (CP) or misorienting the corners. Use commutators like in the Corners First method to insert the SB edges. (approximately 15 – 20 moves)
a. Just pair up the DR corners and insert all the three remaining edges using commutators.
b. But maybe it’s easier to build the SBLine (the 1x1x3 block, that needs to go in the bottom right) on the U-Layer at first. After that you can insert the other to SB edges, like in the 42-Method.

4. CMLL-Skip! (Otherwise something went wrong in CP or CO) (0 moves)

5. LSE: Now you can finish your solve, just like in Roux. (13 moves on avg)

Example Solves (alg.cubing.net):
1st example (smallest substeps explained)
2nd example
3rd example

I think, it's some mix from Roux, 42 and YruRU, but maybe 6CO is totally new? Please tell me, so I can write a wiki article in that case
Thank You!

6co is mehta

 

[StarStarSpace]

6co is mehta

Oh, you're right, 6CO is already existing, thank you. And yes, these algs could be used. But in 1/161 you don't have to worry about a an edge line on the R face, what can make algs much more efficient. For example this RD case on H4 could be solved with U' R U' R(') and the DD U-case (A7) with R' U2 R' U2 R(').
But, wow, this makes it much easier for me to make an alg sheet!
If you have any alternative names to 6CO, just let me know =D

 

[PapaSmurf]

alg.cubing.net

alg.cubing.net

my ribbon method mod but im to lazy to do the last part

Check out Nautilis, because your first couple of steps are the same thing. Also M-CELL. It's basically one of these with a Ribbon finish, either unfortunately or it's a good thing because it means you're thinking on the right track.

 

[efattah]

I need some help with a method idea. Roughly, imagine belt method but the cube is rotated so the 'belt' is the M-slice. Now, from a scrambled position, the first step is to put all L slice pieces into the L slice, all M slice pieces into the M slice. By default now the R slice only contains R pieces. Ignore permutation & orientation of all pieces. How many moves would that first step average? And can it be done in inspection?

 

[PapaSmurf]

I need some help with a method idea. Roughly, imagine belt method but the cube is rotated so the 'belt' is the M-slice. Now, from a scrambled position, the first step is to put all L slice pieces into the L slice, all M slice pieces into the M slice. By default now the R slice only contains R pieces. Ignore permutation & orientation of all pieces. How many moves would that first step average? And can it be done in inspection?

Try inspecting F2L without permutation and orientation and that will give you your answer to the second question. Theoretically yes, but I have no idea about practicalities. For movecount, I have absolutely no idea. Here's a 17 mover done purely on Twizzle with U and E instead of L and M, so I would ballpark 12. I am intrigued what your idea is.

 

[efattah]

Try inspecting F2L without permutation and orientation and that will give you your answer to the second question. Theoretically yes, but I have no idea about practicalities. For movecount, I have absolutely no idea. Here's a 17 mover done purely on Twizzle with U and E instead of L and M, so I would ballpark 12. I am intrigued what your idea is.

I figure during separation of the L-M-R, with a little extra effort it should be possible to solve an EG1 'bar' on the L slice and R slice. If that counts as one step (inspection), then the possible remaining steps would be:
[42] CLL (solves remaining top corners)
ELL on the left side (normally 25 algorithms, but I think it is 50, because you can have a single flip)
ELL on the right side
Solve M slice (orient, permute = 2 steps)
Thus, 5 steps total.

Or, a more advanced variant, ELL on the right side while simultaneously orienting the midges, followed by permuting the midges. This variant is 4 steps but uses more algorithms.

ELL on the left side takes far fewer moves than standard ELL, because you are allowed to modify the permutation & orientation of the M slice and R slice while not breaking the separation of those layers.

ELL on the right side still takes somewhat fewer moves than standard ELL because you are allowed to modify the permutation & orientation of the M slice.

The movecount on the advanced variant would be:
LMR separation while solving two bars: 12
CLL: 8.5 + 1 setup = 9.5
ELL on the left side: 8 + 1 move to adjust the L slice to get the correct starting setup = 9
ELL on the right side while orienting the midges: 9 + 1 setup = 10
Permute midges = 5

Total: 45.5

Each step you look ahead to the appropriate pieces for the next step. Probably the hardest lookahead is the ELL on the left side.

The basic version would have around 42+50+50+5 = 147 algorithms.

Another weirder variant that is likely impractical would be to do LMR separation while orienting the L & R edges. This would be followed by ZBLL on the left side, ZBLL on the right side, and solving the M slice.

 

[THE_V01DL0RD]

It's new. Just a quick thing, COLL solves the corners whilst preserving EO but OCLL orients the corners whilst preserving EO.

idk why but it looks a bit like hawaian kociemba whatever its called

 

[Neuro]

A method / substep combo I've been thinking about for a bit:

1: FB
2: Cross
3: False F2L - form F2L pairs and surround the DR+R center block, occupying the DR-FR-BR-DFR-DBR space but not necessarily a solved 1x2x3
4: Recombinant LL prep - Fix F2L and do some LL influencing, like EO, OLL, CPEOLL, CLL, etc.
5: LL

Example up to recombinant LL prep:

 Twizzle link 

 Setup 

L2 F' D2 F U2 L2 F2 L2 F' U2 F' R2 U R' F' L D2 B' D F

 Moves 

z' U' R2 U' r' x' u U F' //FB
U r' R' U' r' U r' R2 //Cross
U' R U2 R2 U' R2 U R' U2 R //False F2L

Of course, you can get to 2x2x3+final cross edge however you like, but FB->Cross seems efficient, ergonomic, and consistent.

Some common recombinant LL steps are
* Recombinant EOLL - fix F2L and orient LL edges, leaving ZBLL. Efficient and great alg quality, but problems with ZBLL recog and alg count
* Recombinant OLL - fix F2L and perform OLL, leaving PLL. Somewhat high alg count and questionable alg quality, but excellent recog
* Recombinant CPEOLL - fix F2L, perform CP, and perform EO, leaving 2GLL. Reasonable alg count and great alg quality, but very difficult recog
* Recombinant CLL - fix F2L and solve corners, leaving EPLL. Lowest alg count, good alg quality, but questionable recog time

Credit to Athefre for the recombinant step. It is very similar to his work on ACMLL and AOLL, just retooled and given a formal name.

 

[ILCubing]

The CH Method (Charlie Holmes Method or Cheat)
Step 1: Rw Uw x37
Step 2: Use M2 U2 M2 to solve the cube, except you have to play by his rules and do Rw2 R2 U2 Rw2 R2 U2 instead!!!
Step 3: If that did not work, you will have to set it on fire and buy a new one!
Honorable Mention: Use the algorithm

 

[notjamestack]

I have a variant for that. (More Cheating)

Step 1. Try to peel the stickers off,
Step 2. Remember that you have a stickerless cube.
Step 3. Disassemble and try to reassemble the cube.
Step 4. If that didn't work, throw the cube away and buy a new cube.
Honorable mention: 2R, U', 2L', U, 2R', U' 2L, U.

 

[kadabrium]

megaminx cp+1e

https://www.reddit.com/r/Cubers/comments/1lp7w4y/cp1e_new_megaminx_2_look_pll_method_to_get_rid_of

 

[Caleb Valenzuela]

APB CV (APB Variant i guess)
Step 1: make 1x2x3 block on the left
Step 2: make 2x2 block in the back right (on the D layer)
Step 3: form final F2L pair
Step 4: orient the edges and permute the corners while solving the front right pair (algs have not been generated)
Step 5: solve the cube using M and U moves

Pros:
low move count similar to Roux and APB (depends on how long step4 algs are)
Combined Ergonomics of APB and Roux
Mostly intuitive (could be bad for some people idk)

Cons:
Algorithms may be inefficient, long, and too plentiful.

This is just an idea i came up with. Chances are that this method has already been created, but i just gave the idea just in case it hasn’t. I have no experience in this field, so forgive me for my lack of cubing terms.

 

[Twisted101]

APB CV (APB Variant i guess)
Step 1: make 1x2x3 block on the left
Step 2: make 2x2 block in the back right (on the D layer)
Step 3: form final F2L pair
Step 4: orient the edges and permute the corners while solving the front right pair (algs have not been generated)
Step 5: solve the cube using M and U moves

Pros:
low move count similar to Roux and APB (depends on how long step4 algs are)
Combined Ergonomics of APB and Roux
Mostly intuitive (could be bad for some people idk)

Cons:
Algorithms may be inefficient, long, and too plentiful.

This is just an idea i came up with. Chances are that this method has already been created, but i just gave the idea just in case it hasn’t. I have no experience in this field, so forgive me for my lack of cubing terms.

Nautilus

Overview

sites.google.com

 

[Bttyx]

Made a new method for 2x2

BOP method (Block, 6co, 6cp)

1x1x2 block (this takes 1-3 moves, however on most scrambles it is already solved)

6co(similar to metha 6co , orintate remaining 6 corners)(71 cases)

3.6cp(also similar to metha 6cp, permutate remaining 6 corners)(47 cases)

stats:

average move count: possibly 15-20, with algs for 6co and 6cp optimised for 2x2 being generated

number of algs: 118

Variations:
Beginner BOP

1x1x2 block

2.6co- 1(orientate df and db corners)

3.6co-2(oll)

4. 6cs(put white corners in bottom layer and yellow corners in top layer)

5. 6cp(permunate the rest of the cube)

stats:

average move count: 20-25

number of algs:12

 

[Averageof12]

Made a new method for 2x2

BOP method (Block, 6co, 6cp)

1x1x2 block (this takes 1-3 moves, however on most scrambles it is already solved)

6co(similar to metha 6co , orintate remaining 6 corners)(71 cases)

3.6cp(also similar to metha 6cp, permutate remaining 6 corners)(47 cases)

stats:

average move count: possibly 15-20, with algs for 6co and 6cp optimised for 2x2 being generated

number of algs: 118

Variations:
Beginner BOP

1x1x2 block

2.6co- 1(orientate df and db corners)

3.6co-2(oll)

4. 6cs(put white corners in bottom layer and yellow corners in top layer)

5. 6cp(permunate the rest of the cube)

stats:

average move count: 20-25

number of algs:12

The main problem with 2x2 method creation is that it's peak has already happened, for example this is just every other 2x2 method with extra steps. Just a thought, why spend extra time on 6CO and 6CP when you can just make a layer in less then 8 moves, and do CLL? If a cuber doesn't want to learn CLL, then the next logical step would be using winter variation for the last bottom layer corner, which would skip OLL. I would really recommend CLL, as it has almost 1/3 of the algs, If you want to try a 2x2 method with a large set of algs, I would learn LS.

 

[OtaMota]

number of algs: 118

You could do CLL to solve the cube in less looks with a lot less algs

 

[TuanNgoTN]

Hi everyone, I'm Tuan and I created the TN4 method.
TN4 (short for Tuan Ngo 4x4) is a 4x4 speedsolving method proposed by Ngô Anh Tuấn in 2025. TN4 method solves up to F2L-1, starting the 3x3 stage with LSLL.
Speedsolving wiki page: https://www.speedsolving.com/wiki/index.php?title=TN4

STEPS

1. Solve 2 opposite centers.
2. Solve a 1x3x4 block on the left using one of the solved centers (like Meyer method).
3. Solve a 1x3x3 block on the opposite back right, except the top BR edge piece.
4. Solve D center and 4 F3L pairs on the F and B faces (like F3L method, each F3L pair consists of 1 edge piece and 2 center pieces).
5. Rotationless edge pairing using FR slot (the top BR edge piece will be placed correctly after this step to complete F2L-1).
6. LSLL (+ parities).

PROS

• Good lookahead and high TPS are possible in steps 5 and 6.
• F2L-1 is completed prior to the 3x3 stage.
• The blockbuilding and intuitive nature.
• Mostly rotationless.

CONS

• Requires a lot of lookahead and M-slice moves in steps 2, 3, and 4.

EXAMPLE SOLVES
Example solve #1
Example solve #2
Example solve #3
Example solve #4
Example solve #5