Guimond Method Overview

The Guimond method is an interesting 2x2x2 method that is quite different than most other popular 2x2 methods. Despite that, it is fairly simple and doesn't have a lot of algorithms to learn. If you already know the PBL algorithms from the Ortega method, then Guimond only presents 20 new algorithms that you need to learn, and half of those are only 3 moves!

The key to the Guimond method is that in the first couple steps, we treat opposite colors the same. For example, assuming your cube has a standard color scheme, then you would consider yellow and white to be the same color, red and orange to be the same color, and blue and green to be the same color. We first orient the top and bottom with these mixed colors, then separate the colors into their correct layers, and then finally do PBL (permute both layers, the same final step from the Ortega method).

It is possible to predict the separation step during your inspection time, meaning that you can plan out everything up to the PBL during your inspection, effectively making this a 2-look solution. With practice, you can even predict part of the PBL case. Because of this, Guimond can generally have faster solves than the Ortega method, but Ortega might still be useful if you can make an easy face. People have demonstrated sub-3 second averages with Guimond.

Step 0:

Make 3/4 of a face of opposite colors (single color is also acceptable). This step is usually done most of the time, or can typically be done with 1 setup move. It is possible that you will have more than 1 starting position to choose from, so you can pick the one that leads to the best orientation case.

Step 1: Orientation

Use one of 16 algorithms to orient the top and bottom faces (but they will still contain opposite colors). I have included multiple algorithms for some cases. The first algorithm is move-optimal, but the 2nd algorithm can allow for easier prediction of the separation step.

Diagrams below show both the top and bottom layers as viewed from the top.

Top→
Bottom↓
R'U'R (D')RU'R' R'U2R (D')R2UR'
(D')RUR'U'RUR'(U')
(yU)R2'F2UR
R'URU'R'UR(U')
(D')FRU'R'
(x2 to get the
other case)
(U)FU2R'F
FR2F'R'U2R(U')
FR2U'R2FR
(R to get the
PI OLL case)
Top→
Bottom↓
RUR' (D)R'UR RU2R' (D)R2U'R'
(D)R'U'RUR'U'R(U)
(y'U')R2F2U'F'
RU'R'URU'R'(U)
(D')RUR'F'
(x2 to get the
other case)
(yU)R'U2FR
RU'R2FRF'(U2)
(D)RU'R'FR2F'
(R' to get the
PI OLL case)

Note that any final U move is not really part of the algorithm, it is just to indicate how the layer would need to be turned to preserve the permutation.

If you prefer algorithms that use L moves, you might like these algorithms by Odder.

Step 2: Separation

Now, the top and bottom should be oriented, but the colors are still mixed. In this step we separate the colors of the top and bottom layers. There are 5 basic cases. Be sure that the layers are turned correctly before doing the algorithm. Sometimes you can change which case you will get by inverting the last move of step 1. You should learn to do these from multiple angles. Again, the diagrams show both layers as viewed from the top.

R2 R2U2F2 R2UR2' R2U'R2U'R2 R2U'R2U'F2
R2U'R2D'R2

Step 3: PBL

Finally, permute both layers. This is the same final step used in the Ortega method. You can find algorithms on plenty of other sites, like http://www.speedsolving.com/wiki/index.php/PBL

Example Solve

Scramble:
R F' U' F2 U' F R F2 U' R

Solve:
y' //Inspection (Step 0)
U R2 U' R' //Orientation (Step 1)
y R2 //Separation (Step 2)
y U' L D' R U2 R' D L' //PBL (Step 3)

View at alg.cubing.net

Tips & Info

Predicting Separation

Predicting the separation step is key to getting fast times with Guimond. Luckily there are a few tricks to make this easier. First of all, it's quite common for more than 1 solution to step 0 to already be solved when you inspect the cube. So when you have multiple starting positions like this, look for one that has the best orientation case.

Next, you need to know where each piece will move to after you perform your orientation algorithm. To do this, you need to memorize the effect that each algorithm has on the pieces. For example, if you start from a solved state and perform an algorithm, what happens to the pieces? You might notice that some pieces don't move at all! In fact, I chose many of the algorithms above specifically to reduce the number of pieces that move. This will get you off to a good start.

You also don't have to figure out where every piece will move to. You can figure out the separation case if you know where the 4 pieces of either your top or bottom color will move to. For example, if you are solving with yellow on top and white on bottom, then if you can figure out where your 4 white pieces will end up, you can automatically deduce the separation case from that.

If you figure out that you have the "V" (the 3rd separation case) on one layer, that same case will be on the other layer. This case is also the most common, so you should get it about half of the time!

The most important thing is figuring out the separation case for your bottom layer. If you can predict the bottom, but still have to look at the case you get on the top, that's not a big deal because you can recognize the top case nearly instantly. Learning to recognize the bottom layer separation is incredibly easy, because I have provided algorithms for almost every case that only move 0 or 1 piece on the bottom layer. There is one case where 2 pieces on the bottom layer swap positions, but that's easy to remember, too.

Predicting PBL

While predicting the full PBL case you will get is very difficult, it is definitely feasible to predict the bottom layer, especially when you get a lucky case that doesn't require tracking the movement of any pieces prior to separation. The "V" separation case is one of the best separation cases you can get, and it is fortunately also the most common separation case. When you get this case, you know that the left side of your bottom layer wont change, and the odd piece in the top layer will move to the bottom-front-right, and the piece that was in the bottom-front-right will move to the back. Just knowing the position of 3 pieces on the bottom layer is enough to know the PBL case on that layer.

Predicting the bottom layer PBL with most of the other cases is fairly difficult, so its best to try to get the "V" case. (Of course, bars on both top and bottom are easy as well, but that case is very rare)

Full face of opposite colors for step 0

If you happen to get a full face of opposite colors (as opposed to 3/4 of a face), it is possible to simply do a normal OLL algorithm to orient the top face and then proceed to the separation step.

Many of the normal OLL algorithms can be optimized for Guimond to have their move count reduced. However, the normal OLL algorithms which don't affect the bottom layer should be better for predicting separation. I don't recommend using these optimized algorithms unless you can predict the separation with them.

R2'U'RU'R' R2UR'UR FRU2R'F RU'R'F'UF RU2RU2R' R2U'R2FR2F' R2U2R'

Combining Steps

People have often suggested improving the Guimond method by either combining the separation and orientation steps, or combining the separation and PBL steps.

If you are to combine the orientation and separation steps, this results in a LOT of algorithms to learn (hundreds or even thousands). The OFOTA method works similar to this, but reduces the cases a lot by requiring you to get a full face of opposite colors in step 0. The problem with this though, is that it's still pretty hard to predict the PBL step afterwards, so I see this as a lot of work for not much benefit.

The other alternative is combining separation with PBL. This results in considerably fewer algorithms (maybe 60-ish). This could be pretty easy to 1-look, but the recognition of the cases are fairly difficult to recognize, and the existing algs aren't all that great. I think this shows a fair bit of promise, but needs more research before it can really be recommended. Cases and algorithms can be found across several PDF documents posted by Henrik here.

Lastly, there is a method known as HD-G which involves intuitively forcing the "V" separation case, and then using one of 36 algorthms to finish the solve. They call those algorithms "NLL". I haven't learned this yet, but it sounds like it shows some promise.

Progression