Welcome to the Speedsolving.com, home of the web's largest puzzle community! You are currently viewing our forum as a guest which gives you limited access to join discussions and access our other features.

Is this something that people would be interested in reading? I'm trying to get this topic moved to the "How-To" sub-forum but I have to start it here first.

I really want to write a tutorial for solving the big cubes blindfolded, because it really is not as hard as I hear people think it is.

Let me know if you'd be interested in reading something like this, and I'll write one.

I will definitely start writing the tutorial then. I will try to include an overview of how Stefan's method works too, or at least my take on it since I don't know it nearly as well as some others here. Thom, maybe you could add to the part about Stefan's method to make sure it's complete? I don't think I would do it full justice.

Also, freestyle cycling isn't nearly as hard as people think it is. It's basically equivalent to learning a new puzzle, and one that only needs about 10 "algs" to solve for the most advanced method. You could use a more beginner approach and use maybe 1-2 "algs" and still solve a 5x5 or 4x4 blindfolded.

Ok cool, well I'll start writing the tutorial. I'm still refining how I memorize, so I'll include something in there about that, but it'll be light since my method is changing still too.

Keep checking back, I'll go ahead and start writing this.

Chris, I'll start writing this then and send it you once it's finished so you can tag it onto the end. Unless you're already written it, in which case I'll spruce it up

~Thom

'Beginners' Solution To Solving the 4x4x4 Blindfolded

Contents:
Intro
Overview
Edges - Algorithms & Concepts
Special cases
Edge Parity
Centres - Algorithms & Concepts
Corners - Concepts
Tips & Tricks
Application to a 5x5x5

Chris, I'll start writing this then and send it you once it's finished so you can tag it onto the end. Unless you're already written it, in which case I'll spruce it up smile.gif

~Thom

QUOTE
'Beginners' Solution To Solving the 4x4x4 Blindfolded

Contents:
Intro
Overview
Edges - Algorithms & Concepts
Special cases
Edge Parity
Centres - Algorithms & Concepts
Tips & Tricks
Application to a 5x5x5

Hey everyone, this tutorial will end up being pretty long, since I have a lot to say on the subject.

Here is the first installment.

Contents: How to solve a 4x4x4 blindfolded using the freestyle cycling method. This method is 100% intuitive, and is also very fast at solving the cube. I personally have been able to solve a cube blindfolded in under 5 minutes using this approach, and this includes the time to recall the cycles.

Introduction: This approach is using a very intuitive way to come up with commutators or "algorithms" on the fly. Before you stop reading, know that learning a commutator type is the same thing as learning an "algorithm". You will need only 1-2 commutator types, "algorithms", to solve a 4x4x4 blindfolded. I actively use roughly 10-20 commutator types or "algorithms", depending on how you count, in my blindfolded solving. So even using this method to it's most advanced level, there still is not very much to learn since the method is ENITRELY intuitive and requires no memorization whatsoever.

Overview

What order do I use for memorization and solving?
Edges - Algorithms & Concepts
Special cases
Edge Parity
Centres - Algorithms & Concepts
Tips & Tricks
Application to a 5x5x5

The Good Stuff

1) What order do I use for memorization and solving?

Here is the order I use to memorize and solve, and why I memorize and solve this way.

Solving:
1) Corner orientation
2) Corner permutation
2a) Leave parity, if it exists, as (UBL <-> UBR)
3) Edges
3a) correct parity if it exists using an alg that does not affect centers
4) Centers
4a) solve any center blocks created to speed up the solve (more on this in the tips and tricks section)
5:2b) Solve corner parity if it exists

Why memorize and solve in this order?

Let's approach this problem backwards a little bit. What's the easiest part of memorizing and solving a 4x4x4 cube? We will want to memorize this part last, and solve it first. This way you don't have to memorize it well, just take a mental snapshot, quickly put on the blindfold, and then solve that easiest part immediately. Out of the 4 steps to achieve to solve a 4x4x4, orienting the corners for me is by far the easiest step. So that is why I memorize it last and solve it first.

Ok now what is the next easiest step? Well to memorize the centers you have to deal with 24 centers, so that's a hard step. To memorize the edges you have to deal with 24 edges, so that's a hard step. That leaves the corner permutation with only 8 pieces. So memorize this part 2nd to last and solve it second. This way you can take close to a mental snapshot, but make sure you can still remember it after memorizing and executing corner orientation.

Ok so now how do we choose to memorize edges or centers first? Well now let's really think about things. Do we want to cross memorize and cross solve the two? Or do we want to memorize and solve in reverse order? To cross solve would work like this:

There is a problem with solving this way though, and this problem is interference. How much time will elapse from the time you finish solving centers until you solve centers? And how much from when you finish memorizing edges until you start solving edges? If you memorize Edges first and solve them 3rd that's 5 levels of interference. You have to memorize centers, both corner parts, and solve both corner parts before you start solving the edges. This means you have to memorize the edges very well to avoid this interference. For centers you also have 5 levels of interference. This means you have to memorize BOTH edges and centers very well before you start your solve, and this takes time.

Now what if you memorize and solve perfectly in reverse? What happens?

Corners we already know is very efficient. But what about centers and edges? Centers have 4 levels of interference, and edges have 6 levels of interference. When we crossed centers and edges both had 5 levels of interference. Both sum to 10... so which is better?

I say having one have 6 levels and one have 4 is much better. This is because certain memory techniques are stronger than others. So use a strong method for the one with 6 levels and a weaker but faster one for the one with 4 levels of interference.

So which one do we give 6 levels of interference?

Ok now let's stop working backwards to solve this problem. Think about the beginning of a solve. How do we know which faces go where? There are no central most centers to use as guides, so what do we use? Corners? Edges? Centers?

I say centers, and here's why. What is the probability that you have zero centers in the correct location at the start of a solve? This probability is exactly zero! You will always have at least one center already on the correct face. If you don't simply rotate your cube and you will.

Big deal you say, you can do the same with the edges. But the four centers of the same color are completely indistinct. So having them on the right face is all you need, whereas for edges you need to have them in literally the right location out of 24 possible. A center has a 1/6 chance of being in the right location, an edge only 1/24.

This means that you could potentially have lots of centers already on the correct face simply by rotating your cube at the beginning of a solve. Why use cycles to put them on the right face when you can use cube rotations? From my experience I've never had fewer than 5 centers already on the correct face, and I have had as many as 11 already correct just by finding a clever way to rotate the cube before starting my memorization.

So maximizing solved centers before you start memorizing is clearly a good idea. But then do you memorize edges or centers first still? I say centers, because you already have spent some time getting a clear layout of all the centers of the cube from scanning all faces and trying to figure out which way to rotate the cube and get as many solved as you can. If the centers are already in your mind, why not use that to your advantage to speed up memorization a little bit? What if you only need to put one blue center on the blue face? If you memorize edges first you may not remember that and have to re-figure it out. I say use what little bit of knowledge you get about the centers to help you memorize them right now, right at the start.

Now memorizing and solving this way presents a couple problems. First off how do we handle corner parity? Secondly how do we handle edge parity?

Let's tackle the corner parity problem first. How do you solve this on a 4x4? For the 3x3 you use two edges and two corners and perform a PLL algorithm that swaps the two edges and the two corners. But here's the catch, the 4x4 doesn't have these two edge groups, you are direct solving the pieces. Also you don't notice this usually on a 4x4x4 since the centers are indistinct, but if you perform an odd permutation on corners you *MUST* also perform an odd permutation on centers. This means if you swap two corners you must also affect centers. That's bad if the centers are unsolved.

Here are the ways you can handle parity.

1) Create two edge groups that are swapped and use them to do a PLL alg that also contains the two swapped corners. You must do this after centers are solved already.
2) Solve everything on the whole cube except those two swapped corners, and use an algorithm that swaps just those two corners as the very last part of the solve.

I prefer option number 2 and here's why. At what point are you going to look at the corner permutation to determine if you have parity or not? You have to do this before memorizing the edge permutation, to make sure you create those two edge groups that are swapped. Are you going to look at the corner permutation after you memorize the centers? Are you going to use this valuable memorization time to do something completely useless, tracing the CP to see if you have parity or not? What if you don't have parity? You've wasted time to see that you don't have to do anything to handle parity. I prefer to just find out during the memorization of the corner permutation whether or not I have parity, and save it for last.

Ok, now how do you remember that you have corner parity throughout the ENTIRE solve? This is tricky. I always leave the same two corners swapped, UBL and UBR. This way you can just remember that you have parity, and you know parity means (UBL UBR) is your remaining corner cycle.

Ok so that handles corner parity. Now we need to handle the edge parity. Let's take a look at the typical parity alg:
r2 B2 U2 l U2 r' U2 r U2 F2 r F2 l' B2 r2

How does this alg affect centers and why do we care? Well we'll be handling edge parity before the centers have been solved. So we need to make sure our alg is what I call "centers safe" or doesn't affect any centers.

This alg is not centers safe. It performs the centers cycle (frU blU) (flU brU) which is the same as rotating the top center group twice or 180 degrees. So add on an alg that flips it back.

So your new 4x4x4 edge parity alg is:
r2 B2 U2 l U2 r' U2 r U2 F2 r F2 l' B2 r2 R L U2 L' R' U' R L U2 L' R' U'

or some other equivalent that rotates the top center twice after doing the parity swap.

And that is why I memorize and solve like I do. I'l handle the step 4a) above in the tips and tricks section. For now it is not important.

----------

Keep checking back for the later sections. I'll try to post this in installments though and ask for feedback in case I'm writing something in a weird way or something.

Chris, this is an excellent idea. Your webpage seems to contain some of the more straight-forward tutorials (I used it to learn 3x3 and 4x4). And I definitely want to learn BLF, but it seems confusing. Thanks a lot for taking the time to do this.
Pat

Ok so now you have an idea of how to come up with an order to memorize and solve in. I gave arguments for my way, but of course my way is not the only way to do this.

When solving the corners, be very careful to only use supercube safe algs (i.e. don’t twist a center group!! If you do your whole solve will be a DNF!).

Ok so now onto solving the edges. I’ll break this up into an overview of commutators, then list a beginner, intermediate, and advanced method for using them to solve the cube blindfolded.

EDGES OVERVIEW:

What we are going to do is to use nothing but intuitive commutators for this step. I don’t use a single "alg" for this step at all. The purpose is to understand exactly and 100% completely how you are moving only 3 edges at a time.

As you may have guessed I do this step using three cycles, and by doing this you will solve 2 pieces at each step.

The idea of an intuitive commutator works like this. There are certain requirements to start, and the process is always the same once you have met those requirements. So let’s start with what has to be true in order for a commutator to exist to solve a situation.

1) Two of the three pieces to be cycled must be on the same slice.

There are 12 slices on a 4x4x4 cube, and two pieces must be on the same slice in order for you to even consider thinking about a commutator to use.

2) One of the three pieces to be cycled must NOT be on the slice as the other two.

This is very important. So much so that this edge is given a name, the "lone edge".

-----

Ok so now we have the requirements, let’s talk about the process of coming up with a commutator.

Say we have the cycle (bUL->dFL->fUR). Now think about how they look on your cube. You will do a lot of mental picturing of where these pieces are in a blindfolded solve, so preferrably do this without a 4x4 cube handy.

Ok some questions.

1) Are there two pieces in the same slice?

Yes there are, in two different ways. bUL and dFL are both on the L face. Also bUL and fUR are both on the U face.

2) For each of the ways to have two pieces on one slice, does there exist a "lone edge"?

Yes. If bUL and dFL are on the same L slice then fUR is the lone edge not touching L. If bUL and fUR are the two pieces in the U slice then dFL is the lone edge not touching U.

Ok now I have to introduce a concept called "interchangeability". I used to use a weird way to describe this concept, but after talking with Doug Li he hit on this phrase and now it is the one I use too.

Not only do you need two edges in the same slice, but they must be interchangeable. This means that by turning that slice, you can make one of the edges occupy the spot the other originally occupied.

As an example, for the cycle above we have two ways to put two edges on the same slice and choose a lone edge. But which way do we choose during a blindfolded solve and why?

I choose to have the two edges in the U layer rather than on the L layer. This is because the two edges in the U layer are interchangeable and ones in the L layer are not.

Let’s look at the two possibilities:

L layer edges: bUL and dFL. Can you do an L move and put bUL into dFL’s place? No. Can you do an L move and put dFL into bUL’s place? No. So these edges are not interchangeable.

U layer edges: bUL and fUR. Can you do a U move to put bUL into fUR’s place? Yes, U2. Can you do a U move to put fUR into bUL’s place? Yes, U2. So these two edges ARE interchangeable.

-----

Now on to the cycling. Remember our cycle is bUL->dFL->fUR and we have chosen our two edges to the ones in the U layer because they are interchangeable. This leaves dFL to be our lone edge.

Ok now here is the process.

Step 1) Do some move that places the lone edge into the spot of the edge it cycles to WITHOUT messing up anything else on the main slice.

In terms of our example look at it like this. The U layer is our "main slice" because it is the one that the two interchangeable edges are on. The lone edge is dFL. Now look back at our cycle, where does dFL move to? If the cycle again is bUL->dFL->fUR then the dFL edge goes to fUR.

Here’s the key though, come up with some move that moves dFL to fUR and does not touch ANY OTHER PIECE IN THE U LAYER. This is they key that makes this work.

My move to place dFL into fUR without disturing the U layer is R’ d R. If your move is different, then as long as it did not disturb any other piece in the U layer other than fUR then you are ok.

Now we are onto step 2

Step 2) Interchange the unused edge on the main slice to the "action spot".

Definition of terms based on our example. The "action spot" is the part of the U layer you just moved the lone edge to. For our example the "action spot" is fUR. This is literally where all the cycling and all the "action" is taking place.

So of our two U layer edges we dealt with fUR but not with bUL yet. So what was the move to interchange bUL and fUR? Right, U2.

So do U2 now.

Step 3) Do the inverse of the move you did to place the lone edge into the action spot.

Basically take the action spot edge out and put it back in the lone edge’s original spot. For the purpose of our example take the edge currently in fUR and place it in dFL in the EXACT REVERSE way you placed dFL into fUR. If you used my move to place dFL into fUR as R’ d R then now do R’ d’ R to place the action spot edge (fUR) into the lone edge’s original spot (dFL).

Theory: What you are now doing is the A’ part of the basic commutator form A B A’ B’. Part A so far has been our move to place the lone edge into the action spot. B was our move to interchange the unused main slice edge to place it into the action spot. Now we are to A’ in the commutator move which is to undo the move we used for the A part of the commutator. Understanding the theory of what you are doing is very important, but here’s a catch. During an actual speed bindfolded solve, shut your brain off at this point and just mindlessly undo A. You don’t care what pieces are moving where and why, you will know already that just moving the action spot to the lone edge spot will be part of creating a complete cycle.

Step 4) Undo the move you did to interchange the unused main slice edge into the action spot.

For our example, we used U2 here, so now undo with U2 again.

-----

You have now done the commutator R’ d R U2 R’ d’ R U2 which cycles the edges as bUL->dFL->fUR. Now if I had just given you the alg R’ d R U2 R’ d’ R U2 and said learn this, you would have thought that blindfolded cubing is all about learning and memorizing algorithms. But it’s not! We never once thought "Ok I need to use the R’ d R U2 R’ d’ R U2 algorithm since this is the bUL->dFL->fUR cycle" all we did was to intuit how to move those edges.

So here is the process:

1) Find two edges in the same layer.
1a) check to see if these edges are interchangeable
2) Find a lone edge that is not on the same slice as the other two *interchangeable* edges
3) Call the slice with the two pieces your "main slice" and the other edge the "lone edge".
4) Now move the lone edge to the location it goes to based on the cycle. This location will be one of the main slice edges. This location becomes known as the "action spot"
5) Do the interchanging move that moves the unused main slice edge into the action spot.
6) Undo the move you used to place the lone edge in the action spot. You can think of this also as moving the action spot edge to the lone edge spot.
7) Undo the interchanging move you did to place the unused main slice edge into the action spot.

Now that you know how to do it, let’s get onto the only sort of quasi memorizing that you will have to do to get faster at blindfolded solving a larger cube.

------

Beginner method to blindfolded solve a larger cube using freestyle cycling

Ok so now we define the equivalent of algorithms to blindfolded solving. You don’t use algorithms here you use "commutator types". This is basically an algorithm, but remember you do these commutators on any slices, from any angle. This is because you aren’t rotating or reflecting an alg. You’re just using the same process as defined above, but the moves will be fairly similar.

There are two commutator types you MUST use for the beginner level method of free style cycling. Any less and I consider you to be using a method that is unnecessarily hard on yourself and will require a lot of setup turns, which are hard to handle during a solve if you must do a lot of them in a way that is unstructured. Stefan’s method is an exception, since the setup turns are very structured and done with a system behind them. Setup turns in freestyle cycling are as much fun as getting the flu, so avoid them at absolutely all costs.

You must learn these two commutator types if you want to be a good beginner solver using freestyle commutators:

1) The Direct Insert
2) The Drop and Catch

What I do for these is to give an example that is on the U layer to represent each commutator type, but remember there are 24 ways to rotate your cube from each of these examples, and you can also reflect the representative case and rotate it 24 ways. So by learning one commutator type you will know at a MINIMUM 48 algorithms to use during blindfolded solving! Yes that’s not an exaggeration, you will be able to actively use 48 algorithms simply by knowing the process above and the name Direct Insert for example. Also you can move the interchangeable edges around on the main slice and create even more algorithms! So learning these two types teaches you a huge number of algorithms!

The commutator types:
Direct Insert
The representative cycle is rDF->rUF->fUL
The parts
A = F d F’
B = U’

This is my way or writing a commutator type. Here is how to read it. Imagine the cycle rDF->rUF->fUL and see why I call it a direct insert? Let’s find the required parts of what we need to use our process.

Where is the slice with two interchangeable edges? We can choose the inner r slice which has the interchangeable edges rDF and rUF (interchange them by doing eithe r or r’) or we can choose the U slice with two interchangeable edges rUF and fUL. This commutator type chooses to have the U layer edges as our interchangeable edges and the rDF edge as the lone edge.

Ok now that you know the setup look at the A part of the ABA’B’ required form the commutator must take. See how it directly inserts the rDF edge into the spot right above it (the rUF spot)? This shoots the edge directly above it into the U layer. So it is a direct way to insert the edge into the U layer. Think of those pieces as in a line, and you ride the elevator all the way to the top floor.

Now if you do the move F d F’ to place the rDF edge into the newly defined action spot of rUF now what? You have to move the unused edge in the main slice to the action spot. This you do with U’ and that is the B part of the commutator type written above. Ok now you know the theory already, we will do the inverse of the A move next to move the action spot to the lone edge spot (DON’T JUST DO r’!!!! This affects the U layer! Remember you must do each of these steps so as not to affect the main slice in any way other than at the action spot!). Once you have moved the action spot back to the lone edge spot, undo the interchanging move by moving the action spot back over to the original unused spot. So do U here.

So though I only list the A and B parts of an algorithm you know to put them together as ABA’B’.

Ok now here is the catch. Is the cycle dFR->dBR->rUB a direct insert? It’s certainly not going to use the U layer much if at all.

The answer is yes it is. The main slice will be the B slice, with interchangeable edges dBR and rUB. And the dFR edge is in a DIRECT LINE with the dBR edge and ready to insert onto the B slice.

So this situation you would use R f R’ as your insert move, then B’ as your interchange move, then undo the insert move with R f’ R’ then undo the interchange move with B and you have done a direct insert on the B slice.

I’ll leave you to figure out how the following are direct insert cases:
1) cycle fUR->fDR->lDF
2) cycle uFR->uFL->fDL

-----

Ok now onto our second commutator type for a beginner’s approach to blindfolded solving using free style commutators.

The second type is called a "Drop and Catch".

Drop and Catch
cycle: dFL->fUR->bUL
A = R’ d R
B = U2

And this should look familar, it’s the first example we did to describe the commutator mental process. Now why is it called a drop and catch? Remember our main slice is the U slice and the lone edge is the dFL spot. See how we insert the lone edge into the U layer though? We drop it down with R’, then we slide the dFL edge over with the d turn. Consider the lone edge as a fast ball that was moving very quickly, and we dropped the R slice down to catch it before it went by. Then bring the edge back up to the U layer with R.

Now I leave it to you to see how these situations are also a drop and catch:
1) cycle dFR->bDR->rUB (think about the fast ball and trying to catch it. I’ve moved the edges around a bit so it’s not exactly like the first example, but in spirit you still drop a face, then catch the lone edge)
2) cycle dBL->rDF->bDR
3) cycle uFL->bUL->rUB (there are two ways to drop and catch here, find both. One of them will involved doing the drop and catch as BAB’A’ rather than ABA’B’)

-----

Inverting a freestyle commutator

Here’s is how to invert a freestyle commutator. I try to always insert the lone edge into the main slice first, so I am always doing my A move first. However, sometimes this isn’t possible and you need to invert the commutator.

So think about ABA’B’ and what is the inverse? You get BAB’A’ which is the commutator done with the B first! In terms of your thought process all you do is to do the interchange move first, then follow through with the rest.

Say you have the cycle dFL->bUL->fUR

This looks familar right? But now the lone edge goes to the OTHER spot in the main slice, not fUR. Instead of treating the two pieces on the L slice as your main 2 edges and doing a setup move to make them interchangeable, just do the inverse of the drop and catch.

So first I would do U2 which moves the bUL spot to the fUR spot (which will be our action spot). Now I insert the lone edge into the action spot. Then I undo the move I did to place bUL into the action spot. Then I undo the move I did to insert the edge and I finish this way.

***USEFUL TIP*** when doing a commutator when you are actually blindfolded remember this tip. If you start with a main slice move, you end with an insert move. If you start with an insert move, you end with a main slice move.

-----

I’ll stop here, since I think most of the people reading this tutorial are just interested in a way to get started and not about the more advanced stuff. I’ll post another post later that has all the commutator types I consider essential for an intermediate approach, and also every single commutator type I use for the more advanced section. If you count in a very theoretical way I think I use around 20 types. If you just count by names and the spirit of what a situation looks like then I think I use around 10 types. That’s just a guess, I’ll come up with more concrete numbers when I actually do that post.

EDGES - INTERMEDIATE AND ADVANCED METHODS
-----------------------------------------

INTERMEDIATE METHOD
-------------------

Here are all the commutator types I think should be required before considering yourself an intermediate solver using freestyle cycles

1) Drop and Catch (d:U2)
A = R’ d R
B = U2

2) Drop and Catch (d:U)
A = R’ d R
B = U

3) Drop and Catch (d:U’)
A = R’ d R
B = U’

4) Drop and Catch (u’:U) (u’:U’) (u’:U2)
This is following my notation as above.

Drop Catch (u’:U) would be read as
A = R’ u’ R
B = U

the u’ in (u’:U) means catch via the u layer. The U means the B move (main slice) will be U

As another example to make sure this is clear Drop and Catch (u’:U2) would be
A = R’ u’ R
B = U2

5) Direct Insert (d:U’)
A = F d F’
B = U’

6) Direct Insert (d:U) and (d:U2)

7) Direct Insert (u’:U’)
A = F u’ F’
B = U’

8) Direct Insert (u’:U) and (u’:U2)

9) The reflection across the RL axis of all cases above.

Basically know the Drop and Catch and direct insert absolutely to the fullest extent possible. Be able to insert for the direct insert using the u or d layers. Also be able to use interchangeable edges in any positions in the U layer.

For the Drop and Catch know be able to use both the u and d layers, and know how to use interchangeable edges anywhere on the U face.

10) Drop and catch double turn variation (d2:U) (d2:U’) (d2:U2)

(d2:U2) would be
A = R’ d2 R
B = U2

And the others decline just by following the pattern of the notation.

-------------------------------

ADVANCED EDGES METHOD
---------------------

Here are all the commutator types that I use as far as I can think of right now. If I leave any out I’ll try to post them as a followup.

This list includes everything listed in the intermediate method as well as the following.

11) Mostly Face moves type
A = R U2 R’
B = d

This type is Mostly Faces moves (U2:d)
Also know (U:d), (U:d’), (U:d2), (U’:d), (U’:d’), (U’:d2), (U2:d’), (U2:d2)

And if you’re feeling especially adventurous learn these too:
(U:u), (U:u’), (U:u2), (U’:u), (U’:u’), (U’:u2), (U2:u), (U2:u’), (U2:u2)

12) Drop and slide
A = r’ D r
B = U’

This is Drop and Slide (D:U’). Also know (D:U), (D:U2), (D’:U), (D’:U’), (D’:U2), (D2:U), (D2:U’), (D2:U2)

Again if you are confused on the notation I am introducing as an example the Drop and Slide (D2:U’) would be
A = r’ D2 r
B = U’

And if you know all of these very well then you are using the exact method I use to solve the edges of a larger cube blindfold. Remember though that each of these algs can be rotated into all of its 24 possible rotations. Also know the RL plane reflection of each, and each of the 24 rotations of each of those algs.

In reality just think of them as a Drop and Catch, or Drop and Slide, or Direct Insert, or Mostly Face moves type and you will be set. So really this method uses 4 "algorithms" but know that each algorithm has a lot of different ways to manifest itself.

I’ll start work on the centers stuff soon too, so keep checking back.

Pedro, I can help you on corner in a center safe way if you have a specific question, but my english is too bad to write a complete tutorial.

And maybe this alg can help some of you in edge parity. If the centers are solved, and if you do your set-up moves with only 3x3x3 allowed moves, you can use it without turn around any center. It maybe seems limited explained like that, but it's realy a great alg. Uses it !

(rU2)2F2rF2l'U2lU2r2

Remember : center solved and only 3x3x3 set up moves

It's harder to memorise. You can remember the corner very quickly and solve it quickly too. If you memorise this step in last, and if you solve it in first, you don't need a "strong" memorisation. Simply solve it and forget it.

Solve the corner in en center safe way isn't realy hard. Try it