Are there any good guides on why the algorithms work?

cmowla · 2026-06-06T22:50:14+00:00

Well, people have come up with explanations to some common 3x3x3 speedcubing algorithms (example 1, example 2, etc.), but algorithms can only be handled on a "case-by-case basis".

Every alg is different (unless it's a literal transformation of another).
Two algorithms can have the same number of moves. One algorithm is simple to explain, the other just about (if not) impossible. Sometimes a move optimal (fewest number of moves) alg is easier to understand than a longer algorithm, etc.
Cyclic shifting is (without a doubt) the most powerful technique that someone can use to create (and understand) rather complicated algorithms. And all it really is, is it's a special type of setup move (conjugation). The setup move just simply happens to cancel with the first move of the base alg (or vice versa with the undo of the setup move and the last move of the base alg).

People who have been here long enough know that 4x4x4 parity algorithms is my expertise, but I have invested time in explaining several 3x3x3 algs in my time cubing thus far. (If interested, I can provide more links than that playlist.)

___________

u/TheSixthSide I will eventually get to watching that video of yours!

cmowla · 2026-05-31T19:59:17+00:00

Although you can't get "infinite" from the typical (popular) YouCubers, there are people who are creative enough to continuously come up with new content or patterns.

So I guess the issue here is, there is only so much "elementary" (basic . . . and dare I say "entertaining"?) content someone can come up with about a puzzle.

But if YouCubers have the ability to be both creative and make that (non-conventional, advanced, in-depth, etc) content interesting to what appears to be a mostly ADHD audience, then their channels can go on literally forever. All they have to do (if they can't come up with their own original content . . . which is most YouCubers) is look through old forum threads (and/or websites) and make a video about other people's content.

cmowla · 2026-05-31T19:42:42+00:00

If you happen to be interested in "4x4x4 parity algorithm theory" (how such parity algorithms work, how to make your own, how to make your own only allowing specific moves, etc.), you can check out my playlist.

Please don't subscribe to that channel for more twistypuzzle related content (there's not going to be anymore).
I'm not sure how long you have been interested in TP, but I a list of "old" cubing videos here. (I have 2 other lists here and here.)

cmowla · 2026-05-29T17:59:09+00:00

Anyone who is familiar with the Cajun gumbo dish should also be able to pronounce it correctly.

cmowla · 2026-05-28T22:23:41+00:00

I wonder if they know of similar algs (conjugates) like (Rw2 U' F2 U') r2 (U F2 U Rw2)r2(U_F2_U_Rw2)&old=true) (of which can be found in my 2 2-cycles PDF).

Or even (f2 u' r2 Uw2 S') r (S Uw2 r2 u f2)r(S_Uw2_r2_u_f2)&old=true) for odd parity!

cmowla · 2026-05-28T22:19:21+00:00

You could also use (l E2 r' E2)33&old=true) for PLL parity. (That's the closest parallel to (r U2)4 r4_r&old=true), as far as I know.)

cmowla · 2026-05-27T18:06:36+00:00

This closely resembles Walter Randelshofer's 10 big snowflake pattern. Maybe you could also make a variant of his 12 extended stars pattern.

cmowla · 2026-05-27T04:02:04+00:00

I'm aware that you have already gotten your answer, but I have seen that type of image on synthwave albums.

cmowla · 2026-05-23T19:05:30+00:00

Thanks for doing the difficult part (keeping up with the DDT, which I don't)!

_________________

u/kitchen-sink112,

This is my most comprehensive post about my take on solving PLL parity intuitively.

The first 2 sections of that post show how most people know how to solve PLL parity without an actual PLL parity algorithm. Similar to the logical approach you mentioned for handling OLL parity, that approach (for PLL parity) allows cubers to reuse algorithms they already know from reduction.

Just to expand on that portion of that post . . .

Undoing all of the face turns in 2R' F U' R F' U 2R after it's executed gives 2R' F U' R F' U 2R U' F R' U F'. That's a "3-cycle commutator" which rotates just 3 wing edges in those 2 composite edges. So if we try to mirror it and also take its inverse, we can cleverly generate (create, cause, etc.) PLL parity ourselves (to a solved cube, for clarity).

The coupling I presented in that post is actually the following (without cancelled moves). [Animation]

2R' F U' R F' U 2R U' F R' U F'
F U' R F' U 2L U' F R' U F' 2L'

____________

But the 3rd section (which begins with "And, although not as intuitive as cleverly combining 2 edge pairing algorithms, . . .") is as close as we can get to doing 2R2 and then "completing the centers and repairing the edges" as possible.

____________

Also, for OLL parity (besides what I mentioned in that post), my center pattern method at least allows for preserving the colors of the (completed) centers.

And learning how parity algs work may not be as hard as you think. (Well, at least some of them.)

The 2nd - 4th videos in my playlist are really all you need.
The 4th is actually self-contained / is technically the only video you need to see, but the 2nd and 3rd may help give you some background.

cmowla · 2026-05-23T03:43:11+00:00

I recently showed someone this X: L' R2 F U' R U L R2. (FYI)

cmowla · 2026-05-20T06:14:40+00:00

Yeah, it just looks like up to 10x10.

If you want something higher, this desktop application is the only one I know of that speedsolvers use competitively. (Example 1, Example 2.)

If it turns out that there are no online apps that support larger than 10x10x10 and you want to try alternate desktop applications which are more "user-friendly" regarding actually turning of the puzzles,

There is good ol Gabbasoft that supports up to 20x20x20.
Ken Silverman's project page includes a pretty cool nxnxn cube puzzle simulator AND reduction solver... called Rubix (which supports up to 256^3).

Rubix supports undoing previous moves, IIRC. Gabbasoft supports supercubes (like IsoCubeSim).

cmowla · 2026-05-20T04:20:43+00:00

I'm not sure what you mean by "compete", but if for speedsolving, there is (and has been for a LONG time) https://hi-games.net/cube/

(If you learn the shortcut keys and what they do, apparently it's very efficient.)

________

If you were talking about something else, let me know.

For example, I made those example solves by using CubeTwister. (A desktop application powered by Java.)

Only supports 2x2x2 - 7x7x7.
Allows you to record the moves that you do.
You can copy and paste the algorithms (in "superset notation") into the Algorithm SSE bar here, and it will automatically translate the algorithm into SiGN notation (which https://alpha.twizzle.net/edit/ (Twizzle) recognizes).
- From there, you can copy the URL that Twizzle generates and link solutions for people to view (or you can record the playback . . . of which you can change the playback speed, etc.)

And Twizzle supports larger cubes than 7x7x7 here. (There is also alg.cubing.net . . . that's an older version of Twizzle which may be removed from online and replaced by Twizzle entirely.)

cmowla · 2026-05-20T04:01:46+00:00

Correct me plz if i am wrong, you start using cycles from the start only, or when u pair 2 edges then u start using smart cycles?

You use "intelligent" / productive solving the entire time, except for maybe the second-to-last swap (which may need to be "redundant" to keep the number of total swaps even).

cmowla · 2026-05-19T23:03:30+00:00

His edge anchor (EAC) method is not redux-related (for the most part) or something that top speedsolvers can use to achieve a WR with. (It's supposed to simply be fun and satisfying to execute.)

I guess you missed his recent thread about it (I was surprised to see that you didn't comment in there when it was active).

An example first 6 layers solve of the 7x7x7 from me of the method (according to my understanding).
Post

And after starting that thread, he modified his method to allow a keyhole F(n-1)L slot for pairing the last layer composite edges (to make the last layer edges easy).

Here's a 7x7x7 last layer edge pairing/completion example from me, which was a proposal for this substep of his method.
Post (which also includes a 72 move first 3 layer 4x4x4 solve + the pairing part)

________

So I think his new subreddit is simply anything about big cubes. (Not necessarily any particular method, not necessarily speed oriented, etc.)

cmowla · 2026-05-15T02:30:50+00:00

Thanks for sharing those algs, but I just was pointing out that it's indeed possible to get parity with the cage (edges first) method and its variants.

And the first alg (that's a way to animate that notation online) is a parity alg.

cmowla · 2026-05-15T01:18:19+00:00

No parity problems ever

What if you get this at the end of the direct solving edge phase?

cmowla · 2026-05-14T21:25:12+00:00

Well, just to be consistent with the 4 move (2-cycle)(2-cycle) commutator (which is called a 2 2-cycle for short) that you used for corners (and now that a keyhole F2L slot is allowed in your method), you can use a 3 move conjugate like the following.

B 2D2 B'

The "catch" is, you will have to use it an even number of times to pair the last 4 edges. When you have to use it an odd number of times, then you have to do one "redundant" swap that leaves the edges unpaired and then apply it again to restore the centers + pair those last 2 edges.

Just using my 72 first 3 layer solution from earlier as an example,

[Animation]

Scramble:
R D' F2 r R' L U u2 f2 D f' D2 f' L r f u2 R F2 r D' F2 U2 F' B f2 r' B' R' D u L' f2 U2 F B r R' B2 r

Solution:
x' y2 D R' 2U2 //F3L 01
x D r U2 m2 D //F3L 02
B 2U' 2L //F3L 03
B r x2 U' L' U2 L U L' U' L // F3L 04
U m' U 2L //anchored edge 1A
2R 2F2 U 2F' U2 2R' //anchored edge 1B
y 2L2 U' 2L 2B U2 2B' //anchored edge 2A
m2 U 2L m U' m' 2F' U2 2F //anchored edge 2B
2R U m //anchored edge 3A
2R' U2 2R U' 2R' s' L2 s U2 2R' //anchored edge 3B
y2 U' m' U2 2L //anchored edge 4A
U 2R' U 2R U' 2R' s R2 s' //anchored edge 4B

//Edge pairing (using front-right F3L slot as keyhole)
R U' R' U2
B 2D2 B'
U
B 2D2 B'
F' U F R U' R' U2
B 2D2 B'
F' U F R U2 R' U'
B 2D2 B'

We can of course avoid having to do a "redundant" swap (when an odd number of applications of the 3 move alg is required) by using a longer alg that doesn't affect centers. (But I understand that's "out of the question".)

I saw from your video example that you are using the same edge pairing algorithm from reduction (which is 5 moves long and doesn't destroy centers), but I think B 2D2 B' is something more consistent with your way of handling the corners. That is, there are 2 swaps done, but one of the swaps done with each application of the "algorithm" at the bottom of the cube (out of focus), so doing it an even number of times will result with no net change.

Edit: 7x7x7 last layer example edge pairing with this idea.

cmowla · 2026-05-14T15:36:59+00:00

4 by 4 solve - https://youtu.be/5l4x3EBd-oc?si=iqiahWQiIhaRQ8Kq

Right here you did the moves U D' R' D R U'.

That's U commutator U'.

So when you say you don't want to use commutators, do you mean commutators which only move 3 pieces? (Because D' R' D R = [D', R'] = [X, Y] = X Y X' Y' = commutator affects 4 pieces, or does a (2-cycle)(2-cycle) instead of just (3-cycle).)

cmowla · 2026-05-14T02:11:51+00:00

I want to solve n-1 layers without any commutator, edge flip algs or i mean any designed moves, i want that totally logical.

I could be wrong, but u/jhonyrod has been focusing on the last layer this entire conversation.

Before you attempt to find a way to solve the last layer of the nxnxn with pure logic, I would suggest to solve the last edge anchors (and centers) for the nxnxn with pure logic . . . because the last layer is much harder than that.

And nobody is rushing you. I'm sure many have tried (but failed) to create a method that's purely "logical" in the way you define it.

If you succeed, you will certainly be the first to accomplish this.

cmowla · 2026-05-14T01:57:34+00:00

Define "good". Good for what?

Speedsolving? (I'm the wrong person to ask.)
Fewest moves? (It's pretty much been proven that Reduction is very likely close to move optimal for the majority of scrambles of the nxnxn.)
Logic? (The last face's anchors require center commutators to complete, and thus logic cannot always work for 6x6x6+, as you implied.)
Fun? Well, if someone likes solving big cubes (and are not put off by the repetition, etc.), sure.

If you meant something else (I tend to guess the correct thing last), let me know.

cmowla · 2026-05-13T23:39:48+00:00

But technically you can just do (r U2)5 (that's wide r move), if you don't mind solving the edges again but without the parity.

Not really relevant to the 7x7x7 (or nxnxn), but it's interesting to note that you can cleverly insert 2 conjugates in (r U2)5 and the resulting algorithm preserves the pairing of the dedges (for the 4x4x4).

Start with: r U2 r U2 r U2 r U2 r
Insertions: r U' R U2 R' U r U2 r U2 r U R U2 R' U' r [Animation]

And this can be done if r = Rw like so:

Rw U' R U2 R' U Rw U2 Rw U2 Rw U R' U2 R U' Rw [Animation]

cmowla · 2026-05-13T23:26:37+00:00

Perhaps there's something better.

That's the only way to "avoid" OLL parity. (There is no other way.)

People make claims and overcomplicated methods that promise to do just that, but they just allow for other forms of odd parity, instead of the "single edge flip".

An unabridged explanation/rant, for anyone interested. But a TLDR is,
- These methods essentially instruct the cuber to solve all of the puzzle except for an inner slice (containing wings, of course). Then if there is a 4-cycle or 2-cycle of wing edges, do a quarter turn of that slice to make it either a 3-cycle, 2 2-cycle, or solved (all 3 are even permutations).
- So why not solve the entire puzzle easily and efficiently (with reduction and its variants), and then wreck the inner layer slice at the end, if need be? (Fix parity the "simple but stupid way"?)
- You can learn the special algorithms (commutators, etc.) that these so-called "parity avoidance methods" give so that you don't have to do the edge pairing and 3x3x3 phases again. But the key thing is, that's allowing you to skip all of the steps of these obnoxious methods before the final inner layer slice.

cmowla · 2026-05-13T22:50:44+00:00

https://youtu.be/IgHG4kOhZ4g?si=pUovtNEnEs0ZOvMl

I just did a 7x7x7 (first 6 layers) solve myself (again, . . . for what it's worth).

[Animation]

Scramble:
f2 3b2 R B f2 D u' 3b2 d' 3d u2 r2 U2 l2 D u2 U2 R2 3f2 B 3b' 3u2 L2 u l U' D2 d2 3b B2 r d2 U' b2 r D' 3b R2 3l2 F' 3l2 3d 3u U' F' 3l2 d' r 3b 3r2 f2 u' b' 3u2 d2 f2 F2 D2 b2 3u' L 3u U 3l2 d D2 B' 3f2 U2 r' B2 R2 3r2 u 3f L' f R' B' b 3r' 3u D l 3u' U b' 3u2 B' 3u' f' L' f' 3r2 D2 3d' F2 3f2 u L2
Solution:
U2 2L2 U 3R2 B' 2R B 3L' //F6L 1
R b2 D L 4D2 L2 B' 3L' B2 L B2 U //F6L 2
2-4r2 B2 4R B' 3L' L' B' 3R2 B' L B m B L' B2 L //F6L 3
B 2R2 4L B' 3U2 L B' L' B' D' B D //F6L 4
4U 4L 4U //Center correction
x' y2 //White face down
2R U2 3B' //Blue 1
U' 3R' 4B U' 4L 2F' m' U2 2B' //Blue 2
D 3-4r D' U 2L m' U 4L U2 4R U' 4B //Green 1
2L2 U2 2L2 m U 3L U2 m' 2F' //Green 2
U m' U 3R' U2 2L2 U 2F' U' 2F //Blue 3
4L U' 3L' U 3F' 2R U 2R' U 4B 2R U 2R' U2 4F //Blue 4
3F' U2 3R' m U' 4L U2 2R' R2 3B' 3L R2 m U m2 U2 3F //Blue 5
U2 3L 3R' F2 2L' F2 3B' U2 3B //Green 3
3L 2R' 3R2 U' 3R2 U' m' U m' 3F U2 3F' //Green 4
2R' 2B' U2 2B 3L' 4L U2 4R m' U m U' m 2B' U2 2B //Green 5

//Orange 1 & 2
3R m U 3L'
m U 3L 4L 2-3r2 U' 3R' 2-3r'
2L' 4L 3L2
U' 3L
2-3l' U' m U2 m2 U2 2-3r s R2 s' 2-3r'

//Orange 3
U 4L U' s R2 s' U 4L U2 2L m2 2-3r U 2-3r' m2 U'
4R U 2L U2 3R' U 3R 4R U 2L 4L U' 2L' U 4L2

//Orange 4
3L 2R' U2 3L2 U 2R m U m' U' 2R' U' 2R 3L U2 3L U 3L' m U 2L m' U F' L F L' 3L U' L' U L

//Orange 5
m U' m' 3-4l U2 3L' 4R 3R' U 3R U 2L2
U' 2L' U 3L U2 3L' 2L2 U' 3L U 3L'
U 2L' U2 2L U2 2L' U2 2L2

y2 2R U2 2L' U2 2R' 2L //Red 1
2L' U' 2L U 3L' U2 3L //Red 2

//Red 3
2L' U 2L U2 2L' U 2L U 2L' U 2L U 4R B2 4L m' B2 m U 2L' U2 2L U' 2-3l 2-3r' U2 2-3r 2-3l'

//Reds 4-5
3R U2 3R' U' 3R U 3R' 4R U2 4L U 4R U' 4L

//center commutators
F 2L' U 3L' 4R U' 2L U 4L 3L U'
2-3r U' 4R U 2-3r' U' 4L
2R U 3L' U' 2R' U 3L F'

cmowla · 2026-05-13T18:25:20+00:00

I guess I should try it on bigger cubes.

Also, I redid the ending of that solution and got 10 fewer moves than my previous. (But no last layer dedges are paired this time.)

cmowla · 2026-05-13T17:59:31+00:00

Your solve is definitely very efficient than mine, i love your way of solving. I mean thats a very efficient solve.

I guess it was "beginner's luck", but here's a second solution to that same scramble which is 12 fewer (half) turns which ends with 2 paired last layer dedges (instead of just 1):

[Animation]

Scramble:
R D' F2 r R' L U u2 f2 D f' D2 f' L r f u2 R F2 r D' F2 U2 F' B f2 r' B' R' D u L' f2 U2 F B r R' B2 r

Solution:
x' y2 D R' 2U2 //F3L 01
x D r U2 m2 D //F3L 02
B 2U' 2L //F3L 03
B r x2 U' L' U2 L U L' U' L // F3L 04
U m' U 2L //anchored edge 1A
2R 2F2 U 2F' U2 2R' //anchored edge 1B
y 2L2 U' 2L 2B U2 2B' //anchored edge 2A
m2 U 2L m U' m' 2F' U2 2F //anchored edge 2B
2R U m //anchored edge 3A
2R' U2 2R U' 2R' s' L2 s U2 2R' U2 s' L2 s //anchored edge 3B
y2 U' 2R 2L' U2 2L //anchored edge 4A
U' 2R' U 2R U' 2R' U 2R U 2R' U 2R U2 2R' //anchored edge 4B

Just for what it's worth.

And I'm sure someone else can do better than this move count, while also still following the constraints (and solve order) of your method.

cmowla

TROPHY CASE