The New Method / Substep / Concept Idea Thread

[NukesAway]

I know this is stupid but is there an algset that goes from F2L-1 to EO-F2L-1 with a premade pair or a separated pair (SVLS) in U? I want to option select between WV/SV and phasing then ZZLL after this。

 

[ruffleduck]

I know this is stupid but is there an algset that goes from F2L-1 to EO-F2L-1 with a premade pair or a separated pair (SVLS) in U? I want to option select between WV/SV and phasing then ZZLL after this。

You would probably have to do it intuitively. Loosely speaking: EO first, then build pair. (In a smart way of course.) I assume you aren't going to stick to this method anyway since this seems to be a stepping stone to ZB?

(Don't bother with the WV/SV stuff; forcing WV/SV case from LS -> doing WV/SV alg sounds a LOT worse than LS -> OLL.)

 

[Caleb Valenzuela]

Isn't this just 2-look ZBLS?

FRUR'U'F' into ZB?

I could be misunderstanding, but from what I think you are describing, this is just the usual "intuitive" approach to 2-look ZBLS

I guess it’s actually just 2-look ZBLS (I didn’t know that was a thing lol)

 

[NukesAway]

(Don't bother with the WV/SV stuff; forcing WV/SV case from LS -> doing WV/SV alg sounds a LOT worse than LS -> OLL.)

Yeah you have a point, I'll ditch that

I may be using this a lot because there's no way I can memorize all 493 algs
I think EO+create pair/separated pair can reduce a lot of cases compared to ZBLS because it's essentially an unsolved state proplblem , and algs can be shortened because you can choose between finishing with a separated or connected pair according to which finish produces the best algs for a specific case

 

[mdcuber9]

Disclaimer: This method is not near viable for speedsolving at all, however, it is a very simple and easy method for beginners to learn (after all, I created this method on my own with no cubing knowledge)

Overview

This is a completely intuitive and algorithmless 2x2 method for beginners. Basically, the idea is to solve a layer (NOT a face), and then continuing to solve layers until 2 layers are solved. Then, there are essentially 3 cases you could get, and the first leads to next one which leads to the final one. They are: T perm, 2 twisted corners, and flipped bar. To solve the first two cases, you continue solving sides in a certain way to get to the next case. And when you get to the final case (flipped bar), you put it on the bottom right and do L U over and over until it is solved.

This method is extremely inefficient and rather unreliable, but I can almost consistently get sub-30 with it. I will probably post a written tutorial soon. Just wanted to know if there were any other methods proposed out there like this one, because it is extremely easy to learn for beginners!

 

[Caleb Valenzuela]

i don’t think i’ve showed my method here yet, but here it is!

CVOB Method (Caleb Valenzuela’s Optimized Block)
This method takes inspiration from OBLBL and APB. I haven’t calculated the exact average movecount, but judging from my solves (i average around 47 seconds with the method), the average movecount for an average solver should range from around 149 moves to 170 moves (assuming the “average” solver averages the same as me). Here are the steps of my method:

Step 1: Solve the L and R centers (can be any color you want, i personally do blue and green).
Step 2: Solve the DL edge
Step 3: Form the BL edge, then pair it up with it’s corner to form an “F2L pair” (should look like a 3x1x3)
Step 4: Solve the left half of the white center/bottom center, then form the left half of the B layer center, pair it up with it’s edge to form an F3L pair. You should end up with a 3x2x3.
Step 5: repeat the last step but for the right side. When all is completed you should end up with a 3x3x3 in the back left.
Step 6: solve the F layer center while solving the DF edge using F3L
Step 7: do edge pairing. I suggest putting one solved edge/dedge into the DR slot to make the rest of edge pairing easier.
Step 8: Solve 3x3 stage. The original idea used APB, but i found that it was more inefficient for me (i’m not good at APB)

Pros:
Less rotations than other methods
Mostly consists of L, R, Rw, U Uw, L, and D moves, which is quite ergonomic

Cons:
Many M slices are needed
Lookahead is difficult for steps 2-4

The main goal of this method was to reduce the amount of places an edge could be in during edge pairing, while still maintaining a similar movecount to Yau.
Here’s how it started

Spoiler: how it started

I was practicing 4x4 one day and I thought about how annoying it is to have the edge you’re looking for be in the back left, which is completely out of sight. At the same time, my interest for method development started around that time as well. The APB method was my main inspiration for this “journey”. My initial goal was to make an “APB method but for 4x4”. After a post some help threads on this forum, reading and researching articles about method development, I came up with my first method. It was just OBLBL but you don’t make two opposite centers at the beginning of the solve. After that attempt, I took ideas from OBLBL and Max Park’s 15.xx WR 4x4 single to create the method that i am presenting now.

note: this is a very compressed version of how i made the method

Feedback will be very much appreciated!

 

[Caleb Valenzuela]

this might be a bad idea but i asked chatgpt to make a 3x3 method and it’s… something

FLOW Method – 3×3 Cube (Rewritten)​

Step F — First Layer Line​

Goal: Make a 1×3 horizontal line on the bottom layer in the front.

• Hold the cube with your white face on the bottom, front facing you.
• Solve three edges in a row across the front (ignore corners for now).
• Centers must match the edges.

Result: Bottom front edge line is done, back edges and corners still unsolved.

---

Step L — Layer Pairs (Front Only)​

Goal: Solve two corner–edge pairs on the front layer.

• Take the corner + edge pair for the front-left slot and insert it.
• Do the same for the front-right slot.
• Don’t worry about the back two pairs yet.

Result:

• Front of the bottom layer fully solved (edges + corners).
• Back layer corners + edges remain unsolved.

---

Step O — Orient Last Layer Edges​

Goal: Make a yellow cross on top (ignore corners).

• Use simple edge-orienting algorithms until you get the cross:

<span><span>F R U </span><span><span>R' U'</span></span><span> <span>F'<br></span></span></span>

• Repeat as needed.

Result: Top layer edges oriented; back layer pairs still in place but corners not oriented.

---

Step W — Wrap It Up (Corners + Permutation)​

Goal: Solve the remaining back layer corners and edges.

1. Orient Last Layer Corners
   
   • Make all top-layer corners yellow facing up:

<span><span>R U </span><span><span>R' U R U2 R'</span></span><span><br></span></span>

1. Permute Remaining Pieces
   
   • Move corners into correct positions (corner cycle):

<span><span>U R </span><span><span>U' L'</span></span><span> U </span><span><span>R' U'</span></span><span> L<br></span></span>

• Move edges if needed (edge cycle):

<span><span><span>M2</span></span><span> U M2 U2 M2 U M2<br></span></span>
Result: Cube fully solved.

 

[Martyt7777]

front facing you.

 

[Caleb Valenzuela]

View attachment 46146

common sense
uncommon sense

 

[5p33dcub3r]

View attachment 46146

No Back facing you

 

[ErmAcshuelly27]

Do people ever use techniques like non matching blocks for CFOP? For example white cross with one cross edge and its two adjacent pairs having yellow bottom. I understand OLL recognition might be hard with one side misaligned by 90° but if it is a half turn it would be same OLL recognition and pll could be recognized more easily using different u layer colour.

 

[Cuber239]

Do people ever use techniques like non matching blocks for CFOP? For example white cross with one cross edge and its two adjacent pairs having yellow bottom. I understand OLL recognition might be hard with one side misaligned by 90° but if it is a half turn it would be same OLL recognition and pll could be recognized more easily using different u layer colour.

No but I could see why this type of pseudo-solving would be useful, possibly on a very lucky scramble with most of those blocks premade.

 

[Storm V K]

I read about the method 42 the other day, which reminds a lot of roux, but where you solve SB and CMLL slighty differently, and then end up with 7 unsolved edges instead of 6. What if you did CMLL+1? That would give a slightly worse recognition, but end up with L6E. In my head, this sounds pretty nice, but What do you guys think?

 

[ErmAcshuelly27]

I've been trying to develop a megaminx method similar to ZZ. The steps are:
1.) solve a 2x2x2 block
2.) solve another 2x2x2 block opposite to the one you just solved
3.)orient edges so that they can be solved with only, R, U, L , D, and the two faces that don't have names next to DB
solve like ZZF2L twice with one pair in between
4.) LL with edges already oriented.
It's obviously not great for speedsolving because of having to recognize EO mid solve, but it's relatively easy and good to play around with.
*Edit: also not good because you can't see the faces next to BD.

 

[bluecubing]

Me and Elias made a method called CMLEO and he will explain it @precompsubwr

 

[precompsubwr]

CMLEO (Substep of Roux) (3x3)

Usually, while using Roux, you will do these steps: [First 2 Blocks/F2B, CMLL, EO, Last 6 Edges/L6E]
Using CMLEO combines the CMLL and EO steps into one big step.

Example:

 Twizzle link 

 Setup 

B2 L2 D2 B2 D2 F2 R B2 U2 R' U2 R F2 D' L' F' R' D' R F x2 y'

 Moves 

r' F R U r' U' F' U R // CMLEO

Idk if I calculated correctly, but I apparently found there are 1,242 cases to CMLEO. Good luck trying to find all of them.

I believe someone had created this method before, but CMLEO algs include M moves, rather than L/F/R/U moves

And optionally after CMLEO, you can solve L6E all in one algorithm, which will be another 24 octillion algorithms added to your

 

[Caleb Valenzuela]

CMLEO (Substep of Roux) (3x3)

Usually, while using Roux, you will do these steps: [First 2 Blocks/F2B, CMLL, EO, Last 6 Edges/L6E]
Using CMLEO combines the CMLL and EO steps into one big step.

Example:

 Twizzle link 

 Setup 

B2 L2 D2 B2 D2 F2 R B2 U2 R' U2 R F2 D' L' F' R' D' R F x2 y'

 Moves 

r' F R U r' U' F' U R // CMLEO

Idk if I calculated correctly, but I apparently found there are 1,242 cases to CMLEO. Good luck trying to find all of them.

I believe someone had created this method before, but CMLEO algs include M moves, rather than L/F/R/U moves

And optionally after CMLEO, you can solve L6E all in one algorithm, which will be another 24 octillion algorithms added to your

i guess this is the 1LLL of Roux (in terms of alg count)

 

[bluecubing]

i guess this is the 1LLL of Roux (in terms of alg count)

Is there any pro rousxers on here

 

[Caleb Valenzuela]

Is there any pro rousxers on here

@cuar03 (neo cuares)
but he’s never really active

 

[maruc00lestkid]

And optionally after CMLEO, you can solve L6E all in one algorithm, which will be another 24 octillion algorithms added to your

It'll take a while to learn, but once you know cases like Dw' R2 Dw' M2 Dw R2, you'll be able to cut down your times by an extra 3 seconds! Quality m8