The New Method / Substep / Concept Idea Thread

[PapaSmurf]

I understand. That makes a lot of sense. However, I invite you to look at Lin finish as opposed to just Roux Finish. I know that won’t save the method either, but I think that finish has potential and I want to keep working with it.

For the Lin finish, you can do COLL+edge->L5EP or CMLL+edge->L5E. If you do CMLL+edge, you might as well not do eo first and do the blocks like roux.

Hexagonal Francisco is cool, so here is a different finish for it:

1. Build a Hexagon on D (a layer with an adjacent corner and edge missing on the right)
2. Insert E-slice edges (<rUr', RUR', U, u> gen)
3. L5E (what ever method you want)
4. L5C (two commutators or an alg)

This is pretty similar to M-CELL or T-CELL, just an edge in a different place.

It's that method just with a different way to do F2L. L5E should be a nice alg set, and you should do L5C before L5E if you want to do it the best (1 look). And I think it needs to be explored a bit because it could be good, but afaik, L5C->L5E is the best for now.

 

[Hazel]

Hexagonal Francisco is cool, so here is a different finish for it:

1. Build a Hexagon on D (a layer with an adjacent corner and edge missing on the right)
2. Insert E-slice edges (<rUr', RUR', U, u> gen)
3. L5E (what ever method you want)
4. L5C (two commutators or an alg)

This is pretty similar to M-CELL or T-CELL, just an edge in a different place.

I made a variant of HF that I really like:
1) Hexagon + E layer however you like (I usually do Petrus block + F2L pair + edge)
2 or 3) CLS
2 or 3) EODF
4) PLL

 

[ImmolatedMarmoset]

For the Lin finish, you can do COLL+edge->L5EP or CMLL+edge->L5E. If you do CMLL+edge, you might as well not do eo first and do the blocks like roux.


It's that method just with a different way to do F2L. L5E should be a nice alg set, and you should do L5C before L5E if you want to do it the best (1 look). And I think it needs to be explored a bit because it could be good, but afaik, L5C->L5E is the best for now.

I know. I didn’t originally understand that CMLL doesn’t preserve EO. So it would be insert DB edge, then COLL+1, then EPLL. All that is only 47 algs. I’m not trying to prove that this is a good method, I’m just trying to help you understand what I was going for.

 

[PapaSmurf]

COLL+1 is more than 47 algs, unless you do it 2 look.

 

[dudefaceguy]

That's a very interesting method! If you were gonna optimise it for speedsolving, 42 corners would work well with it, or even straight L5C, but that's 614 algorithms, so not really alg free. And I can see how this could be optimised a lot in terms of movecount. When I can, I'll edit this post with some more thoughts on the method after playing about with it.

EDIT: So, I've done a few solves so far, and I think that this method has potential. There just needs to be some speed optimising of the L3E+centres steps. Making that algorithmic would help a lot, but that's not too hard as you can just use comms from bld. The best way to do corners is 42 style IMO, as it allows you to use only 42 algorithms that a lot of solvers attracted to this method will already know (roux), and it's applicable on 3x3 as well. I'm not sure how it compares to Yau, but if it's more efficient, it should stand a good chance, and as you don't get parity, that will also help.

Thanks for trying it out! If you know a CLL algorithm set, then I think you're right that solving two 1x3x4 blocks and then doing the corners of the last layer would be easiest and fastest (this is basically Lewis method). Inserting the last edge in step 3b is not very move-efficient. Solving the corners and this one edge are the least efficient parts of the method, requiring just over 3 moves per piece solved.

I figured the last steps would be difficult to optimize for speed since they rely on slice moves, and speed solvers don't like slice moves. But it would be extremely easy to generate a set of algorithms for the edge pieces of the last slice, since there are only 24 possible permutations, arranged in 6 groups of 4 representing the 4 different positions of a rotated slice. So if you consider the 4 rotations to be a single permutation, then there are only 6 cases, one of which is a skip. In addition, the commutators for the last 3 edges in a single slice are always exactly the same and very easy to recognize.

User Rachmaninovian has already created an algorithm set for centers-last solving which is linked on the Sandwich Method wiki page, so that could be adapted here. There would of course be fewer cases and some more restrictions since we have 6 center pieces in one slice solved already. Much of the move efficiency in the last step of my solves comes from using 4-move commutators to solve lots of pieces at once, but these can be difficult to conjugate so they might not be appropriate for a speed solve. It also takes me about 12 minutes to solve a 4x4, and I'm sure if you spent 12 minutes on almost any method it would be very move-efficient.

Thanks again for taking the time to try it out. I can't really speak to speed solving, but I'm glad that you think it could be adapted to that purpose!

Edit: I just tried a "speed" solve and got 7 minutes, which is good for me I guess!

 

[u Cube]

What if Instead of doing CMLL 4a 4b and 4c you just did CMLL EBL (Edges of bottom layer) then ELL (Edges of Last Layer). Would that be a faster approach, or is it not worth looking into. Please write your opinions below!

 

[PapaSmurf]

No, just no.

 

[WoowyBaby]

What if Instead of doing CMLL 4a 4b and 4c you just did CMLL EBL (Edges of bottom layer) then ELL (Edges of Last Layer). Would that be a faster approach, or is it not worth looking into. Please write your opinions below!

No, it's not worth anything.
Doing ELL alone is less efficient than LSE. The reason is because with ELL, you have less freedom and have to backtrack to solve, but LSE 4a, 4b, 4c, you don't have either of those problems, and each step is very short. (am I making sense?)
The whole not backtracking thing is why computer algorithms like Thistlewaite and Kociemba don't blockbuild.
Many people has had this idea, but its less efficient, requires learning 25 algs, and is slower overall.

I made a variant of HF that I really like:
1) Hexagon + E layer however you like (I usually do Petrus block + F2L pair + edge)
2 or 3) CLS
2 or 3) EODF
4) PLL

This is exactly how the original proposal by Andrew solves the last 10 pieces, if you don’t know.
He also thought of HexagonalFrancisco-CT where you solve L10P with EODF, "TSLE", and TTLL. I think this is the faster approach, and has similar alg count as original because at TSLE, slot edge will already be inserted. Both around 130ish.
Either way is good, original or ct.
Also, like the signature of Hexagonal Francisco is the Hexagon, so solving a 2x2x3 at the start wouldn't be much of a HF variant in my opinion.

I thought of a way of L10P that would require a whole lot less algs:
EO - intuitive, easy, max 5 unique cases
CO - easier than CLS but harder than 2x2 CO. Requires 23 algs.
L5CP - basically the best TTLL's from each set. 8 algorithms. kind of inefficent, perhaps the downfall to this idea?
L5EP - Completely MU 2-gen, 16 algs. recognition may be hard, but algs are very quick.
Slower than 3 step aproaches, but has a third the algs.
What do you think?

 

[Sue Doenim]

Doing ELL alone is less efficient than LSE.

That is inherently false. ELL is in fact a subset of L6E where the user has memorized speed-optimal algorithms for each possible case. Thus, it will always be faster than an intuitively created solution. That being said, bottom layer/top layer is not necessarily better. I think that the method's biggest downfall is the pause for recognition before ELL, and the worse ergonomics as compared to 4c. However, EBL, which includes solving the centers, seems faster than EOLR. With reflections, AUFs, and the guarantee that centers will be oriented (i.e. white or yellow will be facing up, for most people), there are only 24 cases, if I'm not wrong. It seems like they would generally be quick. I feel like most ELLs' bad ergonomics negate that advantage, which, along with the bad recognition, makes it generally worse than standard L6E.

 

[WoowyBaby]

That is inherently false. ELL is in fact a subset of L6E where the user has memorized speed-optimal algorithms for each possible case. Thus, it will always be faster than an intuitively created solution.

Sorry, I wasn’t clear.
Efficient as in movecount.
Definition of efficient: achieving maximum productivity with minimum wasted effort or expense
/ preventing the wasteful use of a particular resource.
In this case, productivity = solving cube, but resource can mean movecount, as well as ergonomics, number of looks, steps, or time (pauses relates to time).

Most of the time, when people say efficient, they mean moves or something of that nature.

Average ELL cases are “deeper” positions of the cube than average LSE cases, they require more moves, thus less efficient move-count wise.

With reflections, AUFs, and the guarantee that centers will be oriented (i.e. white or yellow will be facing up, for most people), there are only 24 cases, if I'm not wrong. It seems like they would generally be quick. I feel like most ELLs' bad ergonomics negate that advantage, which, along with the bad recognition, makes it generally worse than standard L6E.

Here is a Random LSE solution with DF/DB, ELL (Sarah’s ell algs)-
Scr: B2 U’ L2 R2 D F2 D2 L R’ B L’ R D x2
Solution- M U’ M2 U M’ // U2 M2 U M U' M' U' M' U M' U M' U' M U2 [20 moves]
Here is a Random LSE solution with 4a, 4b, 4c (NO EOLR)-
Scr: B2 U’ L2 R2 D F2 D2 L R’ B L’ R D x2
Solution- U’ M’ U M’ // U2 M’ U2 M U M2 // U M U2 M [14 moves]

(I know this is only 1 solve, but it still proves a point)
Even if ELL has slightly better ergonomics or recognition, it wouldn’t make up for the 6 move / 30% moves difference, so it’s slower.

 

[PapaSmurf]

I feel like most ELLs' bad ergonomics negate that advantage, which, along with the bad recognition, makes it generally worse than standard L6E.

I disagree with this, because ell has pretty nice algs apart from maybe one case, plus the recog isn't bad. But the main reason why ebl->ell is bad is because you're being less efficient and the lookahead is worse, as many people can do LSE virtually pauseless.

 

[Solvador Cubi]

Hey @WoowyBaby, thanks for posting info about your ideas for the Kociemba variations.

I'm interested in trying this out, so please keep the info coming! (showing cases in the steps, etc.)



-= Solvador Cubi

 

[WoowyBaby]

Hey @WoowyBaby, thanks for posting info about your ideas for the Kociemba variations.

I'm interested in trying this out, so please keep the info coming! (showing cases in the steps, etc.)

-= Solvador Cubi

I'm so glad people appreciate my ideas! First I made an alg sheet for 2x2 HD here (self-promotion hehe) that was useful,
now a 3x3 method people are intersted in! I'm not sure what else I can provide, maybe some examples of steps, resources for algs, and explanations for easy cases?

So here goes some full example solves with Isom's Kociemba:

Scramble: B' L' F2 D2 B2 R2 B2 L F2 U2 R F2 R' F' L' R' F L2 R F'
y2
R F2 U2 F D' // EO DF
U2' R2' U' R U' R U' // 2-gen CO
E2 R' D' U2 L E2 L' // E-layer placement
U' R2 B2 U2 R2 U' R2 // CS + CP
M2 U2 M2 U' M2 D' M2 // L/R
D M' U2 M z' M' U2 M U2 M2 // 4c
42 STM

Scramble: L R2 B2 L2 U2 R2 U L2 U F2 D' U' R2 L' F R' B2 L D' F2 L
D' R D L2 F // EO
L D U' R' U // CO
E2 R U2 L E2 L’ // E-layer placement
U D R2 // CS
U x R’ U R’ D2 R U’ R’ R2 x’ // CP
M’ U2 M’ D’ M2 y M’ U2 M U2 M2 // L/R
U M’ u2 M x y U2 M U2 // 4c
45 STM

Scramble: L' F2 R' B2 L D2 L2 D2 F2 D2 L' F2 U' B' R F D' R' D F' U
D F R B’ L’ // EO DF (5)
R’ U’ R U2 R’ // 2-gen CO (5)
L E2 L’ D’ B2 U’ R E2 R’ // E-layer placement (9)
y R2 U R2 U R2 // CS (5)
U x R’ U R’ D2 R U’ R’ D2 R2 x’ // CP (10)
y U’ M u2 M // L/R (4)
U’ M u2 M E L2 E’ L2 // 4c (8)
46 STM

Scramble: U2 R F' R2 B U2 B R2 B2 R2 D2 F R2 D2 U L' D' U2 F' L U2
z2
U B U’ D’ R’ F D’ // EO DF
U R’ U’ R U’ R U’ R’ // 2-gen CO
D2 R E2 R’ // E-layer placement
y R2 U’ R2 U’ R2 // CS
U’ y’ R2 U’ B2 U2 R2 U’ R2 // CP
U M2 U’ M’ U2 M’ D' M2 // L/R
D U2 M2 R2 x U M2 U2 M2 U R2 x’ U2 // 4c
51 STM

Scramble: R2 L F' U2 L' B U B' R U' F2 L2 U F2 B2 U D2 F2 D' F2 D'
y2
U’ L U F // EO DF
U2 R’ U’ R U’ R’ // 2-gen CO
D L E2 L’ U’ R E2 R’ // E-layer placement
U’ R2 // CS
U l’ U R’ D2 R U’ R’ D2 R2 x’ // CP
U M2 d M2 U’ M2 // L/R (mismatched)
u M2 u U x M2 U M2 U2 M2 U M2 x’ u2 U // 4c
49 STM

There’s five example solves!

Resources:
These can help with efficiency so much it’s magic!

EO - Many EO cases

CO - All possible 2-gen CO cases

E-layer placement - basically everything revolves around R E2 R’ and L E2 L’, and maybe some R2 F2, and lots of U and D moves to setup to an R E2 R’ case.
See example solves.

CS - So simple, no resources needed

CP -
Diag Top- F R U' R' U' R U R' F' R U R' U' R' F R F'
Diag Bott.- R D' R2 U2 R' U R U2 R U2 R D R'
Adj. Top- l' U R' D2 R U' R' D2 R2
Adj. Bottom- R' D R' F2 R D' R' F2 R2
Double Adjacent- R2 U' B2 U2 R2 U' R2 Double Diagonal- R2 F2 R2
Adj. Top / Diag Bottom- R U' R F2 R' U R' Diag Top / Adj. Bottom- R' D R' F2 R D' R

Permuting Last Edges - For this, you solve a L/R pair just like Roux, then another L/R on the other side, not a lot to learn, but then when you get to 4c step, there are many tricks you can use to finish your solve, such as R2 U2 R2 U2 R2 and Conjugated H-perm.

Stats-
Algorithms: min 5
Intuitive parts that get way better when you learn some efficient algs, cases, and tricks: literally everything
Movecount: about 42-48

This method doesn’t compete for the best speedsolving method, rather, Isom’s Kociemba is a fun novelty method with almost no algorithms and might be useful for FMC as well. (unrelated sidenote: what methods go on the wiki?)
It is possible to be fast with this, but not as easy as with CFOP/Roux.

That’s about it!
Solvador Cubi, hope this is what you’re asking for! If you want me to make a video, I can
~WoowyBaby

 

[VIBE_ZT]

Tesseract Method

Hey guys, I have recently developed a new Pyraminx top-first method. I would like some feedback on it.

I have made a few equivalent Amino posts on it, where I also have videos of the best executions of the algs.

I call this method the Tesseract method. I designed it as an add-on set of algs for any top-first solver, especially one that uses 1-Flip or Oka.
The top consists of a solved edge, and two edges that need to switch. Unlike Nutella, however, these edges don't for a solid block of color on the front.

I'll be honest and say that not all of the algs are the best. I just wanted an alg for every case. Though, some are, in my opinion, are very good.

https://aminoapps.com/c/rubiks-cube...hod-alg-set/Pr8E_ldtmux8ep3vDRdEBWjagx6Pnqlq6
https://aminoapps.com/c/rubiks-cube...algorithms/Bqxl_7JIwu56NKZJxzZ6jdJYL1MpKm11mj

I think that some of these algs might help to turn a bad scramble into a very good scramble.

For example: This case with no centers is U' R' U R' U' R U R. If executed correctly, it can be sub-1'ed easily.


I realize that this method might not be great, but I thought that it would be a fun attempt at trying to come up with something new. Let me know what you think!

 

[Sue Doenim]

Sorry, I wasn’t clear.
Efficient as in movecount.
Definition of efficient: achieving maximum productivity with minimum wasted effort or expense
/ preventing the wasteful use of a particular resource.
In this case, productivity = solving cube, but resource can mean movecount, as well as ergonomics, number of looks, steps, or time (pauses relates to time).

Most of the time, when people say efficient, they mean moves or something of that nature.

Average ELL cases are “deeper” positions of the cube than average LSE cases, they require more moves, thus less efficient move-count wise.

True. I was just being a bit nitpicky about the wording you used in your post from before, because it gave me the impression that you were saying that any L6E case will be solvable faster than any ELL case.

I disagree with this, because ell has pretty nice algs apart from maybe one case, plus the recog isn't bad. But the main reason why ebl->ell is bad is because you're being less efficient and the lookahead is worse, as many people can do LSE virtually pauseless.

Yeah. I wasn't super clear myself. I was including lookahead as part of recognition, since it really is just pre-recognition, and I meant alg speed rather than efficiency.

 

[PapaSmurf]

Tesseract Method

Hey guys, I have recently developed a new Pyraminx top-first method. I would like some feedback on it.

I have made a few equivalent Amino posts on it, where I also have videos of the best executions of the algs.

I call this method the Tesseract method. I designed it as an add-on set of algs for any top-first solver, especially one that uses 1-Flip or Oka.
The top consists of a solved edge, and two edges that need to switch. Unlike Nutella, however, these edges don't for a solid block of color on the front.

I'll be honest and say that not all of the algs are the best. I just wanted an alg for every case. Though, some are, in my opinion, are very good.

https://aminoapps.com/c/rubiks-cube...hod-alg-set/Pr8E_ldtmux8ep3vDRdEBWjagx6Pnqlq6
https://aminoapps.com/c/rubiks-cube...algorithms/Bqxl_7JIwu56NKZJxzZ6jdJYL1MpKm11mj

I think that some of these algs might help to turn a bad scramble into a very good scramble.

For example: This case with no centers is U' R' U R' U' R U R. If executed correctly, it can be sub-1'ed easily.
View attachment 10108

I realize that this method might not be great, but I thought that it would be a fun attempt at trying to come up with something new. Let me know what you think!

It's probably another useful method to know for top first. Just learn more methods, and if you can come up with your own, great! I'm not good at pyra though, so if someone who was good could give their thoughts too, that'd be great.

 

[Solvador Cubi]

I'm so glad people appreciate my ideas! First I made an alg sheet for 2x2 HD here (self-promotion hehe) that was useful,
now a 3x3 method people are intersted in! I'm not sure what else I can provide, maybe some examples of steps, resources for algs, and explanations for easy cases?
...

Great, Thanks so much! I'm sure all this will help me (and others).

I'll be practicing it, but it will take me some time for me to get good at it, I'm sure.
and I plan to be taking my own notes along the way so I can hopefully make another 1 page reference sheet.

It seems like a nice method because even though there are several steps, they are all fairly simple.
(as well as having a low move count!)

In the PCBL step, I'm checking out the "Diag Top" alg you listed, to see if I like it.
It ends in a nice sexysledge, but I've always used: R U’ L U2 R’ U R L’ U’ L U2 R’ U L’ (14 htm)

I'll also need to find a way to intuitively do CO efficiently without memorizing the 72 cases!

Lastly, I don't know enough about Kociemba and how much your proposed steps are similar,
but if it's different enough, I say.. name the method anything you want!


-= Solvador Cubi

 

[WoowyBaby]

Great, Thanks so much! I'm sure all this will help me (and others).

I'll be practicing it, but it will take me some time for me to get good at it, I'm sure.
and I plan to be taking my own notes along the way so I can hopefully make another 1 page reference sheet.

It seems like a nice method because even though there are several steps, they are all fairly simple.
(as well as having a low move count!)

In the PCBL step, I'm checking out the "Diag Top" alg you listed, to see if I like it.
It ends in a nice sexysledge, but I've always used: R U’ L U2 R’ U R L’ U’ L U2 R’ U L’ (14 htm)

I'll also need to find a way to intuitively do CO efficiently without memorizing the 72 cases!

Lastly, I don't know enough about Kociemba and how much your proposed steps are similar,
but if it's different enough, I say.. name the method anything you want!


-= Solvador Cubi

Diag Alg: People do have their preferences for algorithms and I am aware of Diag Top algs besides Y-perm PLL, so I could provide more than one alg per case and slam it on a sheet maybe here- (link)

CO: For CO, understand exactly what an R / R’ move does, then memorize the cases that are only 3 moves, like R U R’.
Then, memorize all 72 cases. This is not too difficult, as many just do a couple moves to reduce it to a 3 move case, so you can memorize a case like: “ok just a Pi OLL on Top is held in back and is “down-left U backhammer”. Boom, memorized. (R’ U’ R U R’ U2 R is the alg you’re wondering)
Not that on Lucas Garron’s Sortega page, every case ends with R, but it can be replaced with R’ if it’s better ergonomically. Ex: R U’ R’ is better than R U’ R

Edit: Doing a single R move changes it to a different case

Idk really what to say about the CO, I’m not an expert or anything.
It’s like looking at a page of all 160 possible F2L cases and thinking it’s impossible to learn, when really, because it’s a semi-intuitive step, it’s far easier to memorize cases than from an algorithmic step.


Kociemba: Kociemba is not a method persay, it’s a computer algorithm used today and invented by Herbert Kociemba.
It is a 2-phase algorithm-
Phase 1: Reduce cube to R2,L2,F2,B2,U,D, state. In other words, Orient all edges, Place middle(equator) layer pieces somewhere in middle layer, and Orient all corners.
Phase 2: Permute the rest of the cube with the restricted move set. Now it’s solved.
The goal of 2-phase algorithms are to split the solve into 2 parts that take roughly the same amount of computing power and moves.

Doing either phase in one step is far too hard conceptually for humans, so there are different methods to do each phase in multiple steps. In the case of Isom’s Kociemba (such a bad name ew), the first three steps are EO DF, 2-gen CO, and E-layer placement. This achieves phase 1. Next phase: CS,CP, L/R, 4c, solves the rest of the cube.
Other methods that do basically this are Orient first, Human Thistlewaite, and SSC.

Just a side note: I’m actually pretty slow with this method.
Holy this is a huge block of text whoops lol.

 

[dudefaceguy]

I tried the method on a 5x5 again and counted my moves this time. I came up with 208 which I think is not too bad, considering that I made some mistakes, was using an inefficient version of the method, and wasn't particularly efficient in general (33 moves to solve the first 2 centers). This seems to be similar to the move count in a reduction speedsolve. It's slightly less efficient than my 4x4 average, at 2.26 moves per piece solved versus 2.17 for 4x4.

The efficiency surprised me at first, because I was expecting this method to be much worse for 5x5. But it actually makes sense, for two reasons. First, solving corners is more efficient and easier because you can solve middle edges at the same time, just as you do in Heise. Second, you can solve 3/4 of the middle slice before the last step, so you end up with a maximum of only 17 unsolved center pieces, compared with 10 on the 4x4. This is about 18% of the total pieces on the cube, which is the same proportion as on the 4x4. Adding the middle slice actually enables us to solve proportionally more of the center pieces before the last step: 65% on the 5x5 vs about 58% on the 4x4.

I modified the methodfor the 5x5 as follows:

1. Opposite centers

2. 1x3x3 block and 1x3x4 block

3. 3/4 of the middle slice

4. Pair (not solve) the last edge of the second 1x3x4 block

5. Orientation of remaining 5 middle edges (this can be done earlier but it doesn't seem to make much difference)

6. Solve all middle edges and corners exactly as in Heise steps 3-4

7. 3/4 of a wing slice

8. 7 wing edges

9. Commutator to solve last 3 wing edges

10. 3-5 center commutators

I also tried a solve on a virtual 7x7, which requires two wing slices to remain unsolved. I ended up with 38 unsolved center pieces in the last step. So, the method will work for any nxnxn cube, but it just gets progressively less efficient as the cube gets larger because there are proportionally more center pieces versus wing edges. But hey, at least you don't have to learn any parity algorithms!


I actually found the5x5 solve to be extremely fun, since there is so much variation in the different techniques used. I never really paid attention to 5x5 because I don't like reduction solves, but now that I have a direct intuitive method, I'm having a heck of a lot of fun! I might actually enjoy it more than the 4x4 version.

 

[WoowyBaby]

@dudefaceguy Here's some 4x4 example solves with your method-
"1. Solve two opposite centers.
2. Solve a 1x3x3 block and a 1x3x4 block (similar to Roux) on the opposite face.
3a. Solve two more corners such that the last 3 corners are out of place, then solve the last 3 corners using a commutator.
3b. Solve the last edge pair of the 1x3x3 block to extend it to a 1x3x4 block.
4. Extend one of the 1x3x4 blocks into a 2x3x4 block by solving one middle slice excluding the top layer.
5. Use the unsolved slice to solve exactly 7 of the remaining 10 edge pieces.
6. Solve the remaining 3 edge pieces and some center pieces with a commutator.
7. Solve the remaining center pieces with 2 or 3 commutators."

Scramble: D2 L R2 F2 L2 R2 D2 B L2 U2 B' U2 B2 F' U' F2 D2 L2 R' U' R Fw2 Rw2 R' B2 D2 Fw2 F L' B Uw2 F D2 B' Uw L2 Uw2 L' B2 Uw' B Rw Fw B Uw2 U Fw2
x2
R2 f r U2 r' U R' y r U2 r' z // 2 Opposite Centers (10)
R U R2 L U' r' U' F' L2 F // Red 1x3x3 (10)
R2 U' r L F' L D L2 U R' U' r2 R' F R2 F' R' U R2 U' R2 U' R U r' U2 R U R' U' R y D' R U' R' D // Orange 1x3x4 (36)
y U2 R' F2 R F' R' F2 R2 U R' // Corners (10)
U' R l L R2 D' R2 L2 U R' // Remaining Edge (10)
2R U 2R' m' U m' D2 U m' U m D2 2R U' 2L2 U2 m2 U 2L' U2 2L m U2 m' 2R2 U' 2R2 U m U2 m2 U2 m 2R2 U 2R2 U' m' U2 m // Left M slice (40)
U2 2R U2 2R2 U' 2R2' U2 2R U2 2R2 U 2R' r U R' U' 2R' U R U' R' // Solve 7/10 Edges (21)
// Non-Intuitive Near-Impossible L3E Commutator
// Non-Intuitive Near-Impossible Last 12 Centers Commutators
137 STM + ~40-50 for the rest = 180 ish

This method is extremely difficult to solve with, not for beginners whatsoever, requires a very high level understanding of the cube, many parts are too complex to do efficiently.
I spent actually over an hour on the solve, because how complicated it is.
Algorithms are easier to understand than commutators.
I actually know exactly how commutators work, and have lots of experience on 3x3, but I didn't grasp this.
Even in your own video you struggled near the end to solve using your own method.

This is an interesting method, maybe just not for me
Maybe other people will like it though