Blindsolving 101 Part 1: Recognition, Memory, and Algorithms

Introduction

Over the next few months, as Jaylen and I develop our Rubik’s Cube club, I plan to explore and document my process of learning and researching topics in cubing, specifically blindfolded cubing, the fewest moves challenge, and the pedagogical search for an ideal beginner’s method. There has already been some blindfolded cubing content on this blog, and so that is where we will begin.

There is already plenty of great blindsolving tutorials out there, so I won’t be trying to replicate them. Instead, I want to document the difficulties and tips & tricks that I discover along the way. For the club, we will most likely organize an array of presentations (powerpoint or beamer) to teach blindsolving. And for the purposes of this post, let’s use JPerm’s blindfolded tutorial as a reference.

When I first learned how to blindsolve, I found the process to mainly consist of three stages, each with its own difficulty to overcome. The three stages, in the order that they are executed during a blindsolve, are recognition, memorization, and application of algorithms. First, we have to recognize the pieces and where they need to go, in the process forming cycles that will solve all the edge and corner pieces, while keeping track of which pieces we have accounted for and effectively “solved” already. In order to keep track, we will also develop a compact memory system by assigning single letters to each sticker (one of three sides of a corner piece or one of two sides of an edge piece). We assign letters to stickers instead of pieces in order to account for the “twist,” or parity, of the pieces. On a standard 3x3x3 Rubik’s cube, there are 24 edge stickers and 24 corner stickers in which we are interested: four on each face. This actually has an interesting way of generalizing to larger cubes, allowing us to potentially solve them blindfolded as well.¹

This system of assigning letters is known as the Speffz Lettering Scheme, and is the most widely used among blindsolvers. In official WCA blindsolving, the memorization phase of a blindsolve is counted for time. So to use the Speffz lettering scheme effectively, we must memorize it by heart and associate the letters to the colors. This leads us into the second stage: memory. Whatever we recognize needs to be paired up and memorized fast and accurately, even if this memory only needs to last for the duration of the solve. Because 3x3x3 blindsolves typically use around twenty letter pairs, we do not necessarily need to employ the Loci memory technique, at least not for the edges as they are memorized last and solved first. After this stage we will have to execute the algorithms corresponding to the letter pairs we memorized earlier. Thankfully, we need not memorize an algorithm for every possible letter that we encounter as most of these algorithms use a general “swapping” algorithm and apply setup moves to make sure the appropriate piece(s) gets swapped. We will not be going into more depth regarding the blindfolded method. For reference, I will be using the OP/M2 method – the Old Pochmann method but the edge stage is replaced by M2 slice moves. I don’t plan on learning the more advanced 3-style method until I get close to the sub-minute mark for blindsolve times using M2/OP.

Recognition

Out of the three stages, recognition is my weakest stage. In my opinion, it also tends to be the most overlooked stage, since we’re more intrigued by the part where we have a blindfold on and our friends are watching in scrutiny and fascination. Many would print the Speffz lettering scheme on a sheet of paper and reference it. I went a step further and bought a cheap cube to label it with the Speffz lettering scheme. But I think, pedagogically speaking, we could safely state that memorizing the lettering scheme should be a requirement. We must be able to take a piece on a Rubik’s cube and almost instantaneously recognize the corresponding letter on a 3x3x3 cube.

Earlier, I made a post about resources I created for the use of Anki (a flashcard testing software) to memorize the Speffz lettering scheme.² The goal here is to eventually be able to turn the recognition into a reflex reaction. Hence, the path we take to get there will not matter so much as we ultimately attain independence from intermediary steps in processing the pieces. And thus, we could select easier mnemonic methods to drill the letter scheme into memory. I’ll go through the mnemonics I tried to devise, but I ultimately encourage the viewers to come up with their own, as everyone’s associative memory work differently.

But before that, a quick discussion regarding color schemes: on the default Rubik’s cube color scheme, there are six ways to select a face to use as the “top face,” and then in each case four ways to select a face to use as the “front face.” Hence, there are actually 24 unique ways to apply the Speffz lettering scheme unto the cube. Standard convention, including the WCA’s official regulations, encourage using white top and green front. Admittedly, many notable blindsolvers use “non-standard” color schemes, including world record holder of the single fastest official blindsolve Jack Cai, who uses blue top and red front because “that’s how he learned it” according to him. Still, since committing a letter scheme into your memory reflexes is a pretty big commitment, you should only use one letter scheme, and I argue that memorizing the standard color scheme is the best choice, as ease of communication within the community would definitely benefit you as you start blindsolving. Please do take my opinion with a grain of salt, as this is not a huge issue, and you are free to use whichever color scheme you want. (Red top yellow front? Go for it!³) I am only suggesting that white top green front is a good choice for beginners. The resources I create will also assume that you are using the standard white top green front scheme.

Corners

My method for making the most out of the Anki deck I made previously involves a modular approach. I first messed with my Anki settings (on an experimental profile) to disregard most of the spaced repetition features and allow me to just go through the deck as it only contained 24 flashcards. The key is to treat pieces as collections of stickers. Since there are four letters per face sharing the same sticker color, we have to rely on the other stickers on the same piece to deduce the letter of this particular sticker at hand. Hence, thinking in terms of faces is not beneficial. Instead, we could learn to recognize a piece and state the three letters on the piece, at first without concerning which letters correspond to which colors. We could then use our knowledge of the scheme – which letters correspond to which colors – to deduce the letter of the sticker at which we are currently looking. This method worked for me as it followed the process in which I processed the information present on the cube.

First, it is important to remember which letters correspond with which colors.

• A through D (A, B, C, D): White (Top) Face
• E through H (E, F, G, H): Orange (Left) Face
• I through L (I, J, K, L): Green (Front) Face
• M through P (M, N, O, P): Red (Right) Face [Red = Right]
• Q through T (Q, R, S, T): Blue (Back) Face [Blue = Back]
• U through X (U, V, W, X): Yellow (Bottom) Face

The letters Y and Z are not used, and the “red is right, blue is back” mnemonic is a pretty useful sanity check even though it does not guarantee that your orientation is correct. Always check white top and green front to be sure. Another potentially helpful mnemonic is that the first letter of each face forms the string “AEIMQU,” which are basically all the vowels except “O” is replaced by “MQ.” At this point, I must point out that a lot of the memory-related techniques we will cover are heavily intertwined with language. While there definitely exist different systems for other languages (I’m aware of Chinese systems using Chinese characters and also Russian systems utilizing the Cyrillic alphabet), we will focus on English, although it could theoretically be modified to work with other languages, especially those that use the latin alphabet.

I would recommend knowing the colors well, as they are quite fundamental and apply both to corners and edges. Next, we will move on to the corner pieces, of which there are eight on a Rubik’s cube. If we arbitrarily adopt the convention of labelling them with their top/bottom (white/yellow) face and then spinning counterclockwise, we get the following table.

Corner	Colors	Possible Mnemonic
ARE	White, Blue, Orange	The word “are”
BNQ	White, Red, Blue	Legendary programmer Benjamin Qi (BenQ)
CJM	White, Green, Red	“C jam”? Jazz?
DFI	White, Orange, Green	The word “defy”
ULG	Yellow, Green, Orange	Anagram of “ugly”
VPK	Yellow, Red, Green	Voluntary Prekindergarten (Pre-K)
WTO	Yellow, Blue, Red	World Trade Organization
XHS	Yellow, Orange, Blue	Xhosa - South African Language

The mnemonics presented above help us literally memorize the three letters. It could be argued that the order in which these letters appear in is not important, and hence we should be allowed to scramble them in order to find better mnemonics. However, I’m satisfied with most of the words I could make with these triplets. If you feel the need to scramble the letters, do so by all means. I have yet to find any concrete advantage of this labelling convention.

It remains for us to somehow associate these mnemonics to the colors, on which we will rely to recognize these corners. I’m no memory expert, and at this point I was out of methodical ideas, so I just let it naturally happen. For DFI, or “defy,” the colors match Ireland’s flag, so I just through about the Irish war of independence. For WTO, the World Trade Organization’s logo consists of blue and red (and green, but we’ll ignore that), and yellow (gold/Chinese colors) because of WTO’s influence on the economic growth of China. BNQ could be a Russian flag due to the Russian hacker stereotype, but that is definitely a bit of a stretch. For ULG, it just so happens that yellow, green, and orange are not among the colors towards which I have an inclination, which makes that easy to remember. Remember, the rationale here is to use these mnemonics as an intermediary tactic before this recognition process, which you’ll have to keep doing over and over again as you blindsolve, becomes second nature.

At this stage, you should test yourself on the Anki corners deck, but just testing on piece recognition: after seeing the piece, say the three-letter combination that represent that corner piece as fast as possible, disregarding which piece is clearly in the “center” spot.

Once these are drilled in, refer back to the top of this section where the ranges of letters are listed with their corresponding colors. Adding one step to the previously established recognition process, find the only appropriate letter for the “main” color, i.e. the sticker, of the piece at hand after recognizing the piece. For example, if you were looking at the orange sticker of the white-orange-green piece, recognize that the piece is DFI, and that since orange ranges from E-H (E, F, G, H), the sticker must be F. This actually requires substantial familiarity with the order of the Latin (English) alphabet, which is something that is easy to overestimate as we all learned this in kindergarten. Try practicing by singing the alphabet forwards and backwards–you may be surprised by the difficulty of the latter!

This process seems unreasonably long and complicated, but it reduces a daunting task–the ability to recognize letter based on stickers using the Speffz lettering scheme–to a sequence of simple and repeatable deductions. Once you’ve done this enough, you will stop thinking about these steps. My belief in this strategy mainly lies in the fact that this is how we perceive information about a particular sticker during blindsolves: we look at its other sides to locate “where it should go on the cube.” In fact, that is what I used to do: I would visualize where this piece should go under the default white-top green-front orientation, and then mentally apply the counterclockwise Speffz lettering scheme to find the sticker. This process was far too slow, tedious, and frankly unreliable–there is indeed a need to memorize it.

Edges

The edges could be figured out in much a similar fashion. However, unfortunately, it doesn’t seem to be as easy as the corners. There are ways to figure out the edges from the corners, but those seem to take up too much computation to be worthwhile. Thus, let us look at mnemonics once again. Utilizing the same idea of letter ranges to choose the appropriate letter from two letter pairs this time, we could list all the edge pieces and attempt to associate them with the colors.

Edge	Colors	Possible Mnemonic
AQ	White, Blue	Aqua: clouds and the sea
BM	White, Red	MB: MBA - white collar, red pen for suggestions as a consultant*
CI	White, Green	IC: Iceland, white for snow, green for grass
DE	White, Orange	DElhi: orange and white are the top colors of the 🇮🇳
LF	Green, Orange	Leaf: green in summer, orange in autumn
JP	Green, Red	Japan: Red for the rising sun, green for eco-friendliness
TN	Blue, Red	NT: NATO, blue versus red
RH	Blue, Orange	Rhine river: blue for water, orange for germany, the name’s origin*
UK	Yellow, Green	Sunflower: national flower of UKraine
VO	Yellow, Red	OVer the horizon: yellow and red sun*
WS	Yellow, Blue	UKraine: West and South of Russia
XG	Yellow, Orange	eXtra virGin olive oil, yellow/orange in color*

Here’s my best attempt. I’ve marked associations that are weak in my opinion with an asterisk (*). Remember that this is all subjective. Note that I’ve liberally flipped the orders in these examples as there are already so few associations one can make with the colors. Another negative about memorizing edges is that you have to remember more smaller pieces of information as compared to corners. In this regard, I find corners easier to memorize using this method. Focus on converting the colors through the recognition mnemonic into letters and not the other way around. The plan at this point is exactly the same: drill these in using Anki.

Again, this is only one method of recognizing pieces that I came up with. I’m sure other people have employed similar methods, and others yet probably used vastly different methods (including visualization) and still found success. But if, like me, you find that your weakness lies in the recognition process, give this a try.

Memory

In a competitive blindsolve, as we recognize the pieces and where they belong to generate cycles, we must also find a way to remember that information so we can solve those cycles once the blindfolds go on. The Speffz Lettering Scheme provides us with letters to remember, and in the last stage, we are expected to know algorithms to solve these cycles provided with the relevant letters. The memorization stage is what chains those two stages together and make the magic happen.

Blindsolving the 3x3x3 cube takes neither too much memory or too much time, especially when compared to blindsolving larger cubes or multi-blind (memorizing many cubes and solving them in sequence). Hence, the cycles, chunked into “letter pairs,” do not have to remain in our memory for that long.

We can modify our memory system(s) as we gain experience, and we don’t need a complete system to begin: we only need to be able to recall the letters accurately most of the time, being careful not to mix up letters like C/K/Q. To start, there are two main basic methods of memorizing letter pairs: words and audio. First, we could associate each letter pair we get to a word that is easy to remember and could be converted back to the letter pair on demand. This could be used in tandem with other techniques like [Loci][loci-memory-technique] or Roman rooms. This technique is advantageous in its scalability. Alternatively, we could make a sound with the letter pair, inserting a vowel when necessary. This technique is known as audio. To disambiguate between similar sounding consonants we may want to swap out some of them for diphthongs. The sounds we derive will usually make no sense, but the vocalization is enough for us to remember them and the letter pairs to which they correspond for a short period of time. This makes audio an especially desirable technique for memorizing edge pieces as they are memorized last and executed first; corners, however, should stick with word association.

For the word association method, check out JPerm’s template on Google Sheets: it is specifically tailored for the beginners method or M2/OP, and blocks out the letter pairs that will never occur during a standard blindsolve so you won’t have to worry about them. For the audio method, here is an explanation by Jack Cai.

Initially, memory was quite difficult for me, as I needed to remember a new “story” or “sound” for every solve. I found it helpful to stick with one scramble, write down the scramble and my blindsolve solution on a sheet of paper, and keep practicing that one solve until I could get it successfully. This way, I got to troubleshoot any execution or memory errors in my blindsolve (sometimes with the blindfolds off) to fix any lurking problems in my memory and algorithm skills.

Algorithms

The algorithms part is perhaps the easiest for the M2/OP method. If you can visualize the Speffz lettering scheme, you may even visualize the cube and find the set-up moves intuitively (without memorization). Regardless, I’ve provided the algorithms and optimizations that I use below.

OP Corners

For corners, we will use the Old Pochmann system. Most of the OP algorithms use the modified Y-Perm as the swapping algorithm. Hence, the ARE corner is the buffer, and the position of the VPK corner is the target. The default [Y-Swap] swaps A with P. Since this is not meant to be a tutorial, we will go directly to the algorithms and optimizations.

[Y-Swap] := (R U' R' U') (R U R' F') (R U R' U') (R' F R)

Here are the basic setup moves to each piece/algorithm. Faster moves like D and R are favored over more cumbersome moves like F and B for setup moves. I’ve also indicated on the rightmost column whether I am aware of any further optimizations (F.O.) to these algorithms (which are usually setup to other PLL algorithms).

Position	Algorithm	F.O.
A (UBL)	cannot swap with buffer ARE
B (UBR)	R D' [Y-Swap] D R'	Y
C (UFR)	F [Y-Swap] F' a.k.a. [Y-Perm]
D (UFL)	F R' [Y-Swap] R F'
E (LBU)	cannot swap with buffer ARE
F (LFU)	F2 [Y-Swap] F2
G (LFD)	D2 R [Y-Swap] R' D2 {F2 R' [Y-Swap] R F2}	Y
H (LBD)	D2 [Y-Swap] D2
I (FUL)	F' D [Y-Swap] D' F
J (FUR)	R2 D' [Y-Swap] D R2	Y
K (FDR)	R F [Y-Swap] F' R' {D R [Y-Swap] R' D'}	Y
L (FDL)	D [Y-Swap] D'
M (RFU)	R' [Y-Swap] R	Y
N (RBU)	R2 [Y-Swap] R2	Y
O (RBD)	R [Y-Swap] R'	Y
P (RFD)	[Y-Swap] {no setup needed}
Q (BUR)	R' F [Y-Swap] F' R
R (BUL)	cannot swap with buffer ARE
S (BDL)	D' R [Y-Swap] R' D	Y
T (BDR)	D' [Y-Swap] D
U (DFL)	F' [Y-Swap] F
V (DFR)	F' R' [Y-Swap] R F	Y
W (DBR)	R2' F [Y-Swap] F' R2	Y
X (DBL)	D F' [Y-Swap] F D'

And the following list contains some possible optimizations that would save a few moves during execution (and thus time). My favorite optimizations are those that swap an algorithm out for a PLL, which I already know. This way I will have to remember less and execute more. Granted, if you don’t know full PLL, some of them might not be so useful. They’re not guaranteed to be faster or more move-efficient than the standard algorithms, and I don’t personally use all of them, but I use the move cancellation ones and also whichever ones feel comfortable especially when blindfolded.

Position	Optimization	Moves
B	[Ja/L Perm]	(R' U L' U2) (R U' R' U2) (R L) U'
D	U2 [J-Perm into U]	U2 (R U R' F') (R U R' U') (R' F R2 U') R *U*
G	F U2 [J-Perm into U] F’ {cf. case D}	F U2 (R U R' F') (R U R' U') (R' F R2 U') (R U F')
J	[No starting R’ L-Perm] U’ R’ {cf. case B}	U L' U2 (R U' R' U2) (R L) U' R'
K	U’ R U’ [J-Perm into R2’] U {cf. case D}	U' R U' (R U R' F') (R U R' U') (R' F R2 U') R2' U
M	Move cancellations with [Y-Swap]	(** U' R' U') (R U R' F') (R U R' U') (R' F *R2*)
N	Move cancellations with [Y-Swap]	(*R'* U') (R' U') (R U R' F') (R U R' U') (R' F *R'*)
O	Move cancellations with [Y-Swap]	(*R2* U' R' U') (R U R' F') (R U R' U') (R' F **)
S	Apply case O: D’ [Case O] D	D' R2 (U' R' U') (R U R' F') (R U R' U') (R' F) D
V	Apply case M: F’ [Case M] F	(F' U' R' U') (R U R' F') (R U R' U') (R' F R2 F)
W	U’ R2 U’ [J-Perm into R] U {cf. Case D, K}	U' R2 U' (R U R' F') (R U R' U') (R' F R2 U') R' U

M2 Edges

Old Pochmann is a stable/reliable but inefficient method, simply because the swapping algorithm takes too long. The OP method solves corners, edges, and parity. Parity is when the corner and edge pieces both have odd numbers of swaps (as opposed to even numbers of swaps), and in such cases an algorithm needs to be performed after the edges are solved and before we move on to the corners. Instead of using OP edges, we use an alternative method known as M2, where the swap move is simply the slice move M2. This shortens the lengths of our algorithms greatly, but it introduces a few extra complications. First, The CI and WS edges are now on the moving slice, and they will have to be executed differently depending on whether they occur at the first or second operation of a letter pair. On the first letter of each pair, these four letters are executed as is; whereas on the second letter, C and W are swapped as well as I and S.

There are many ways to set up M2 algorithms, and none of them have reasonably simple optimizations due to how simple M2 is already. My preferred algorithms are due to Jack Cai and are listed below.

Position	Algorithm
A (UB)	M2
B (UR)	R U R' U' (M2) U R U' R'
C (UF)	U2 M' U2 M' (Inverse: W)
D (UL)	L' U' L U (M2) U' L' U L
E (LU)	x' U L' U' (M2) U L U' x
F (LF)	x' U L2' U' (M2) U L2' U' x
G (LD)	x' U L U' (M2) U L' U' x
H (LB)	Uw R' Uw' (M2) Uw R Uw'
I (FU)	U' (R' F' R) S (R' F R) S' U M2 (Inverse: S)
J (FR)	U R U' (M2) U R' U'
K (FD)	cannot swap with buffer UK
L (FL)	U' L' U (M2) U' L U
M (RU)	x' U' R U (M2) U' R' U x
N (RB)	Uw R Uw' (M2) Uw R' Uw'
O (RD)	x' U' R' U (M2) U' R U x
P (RF)	x' U' R2 U (M2) U' R2 U x
Q (BU)	(U M')x3 U M (U M')x4 {(U' M)x3 U' M' (U' M)x4}
R (BL)	U' L U (M2) U' L' U
S (BD)	M2 U' S (R' F' R) S' (R' F R) U (Inverse: I)
T (BR)	U R' U' (M2) U R U'
U (DF)	cannot swap with buffer UK
V (DR)	U R2 U' (M2) U R2 U'
W (DB)	M U2 M U2 (Inverse: C)
X (DL)	U' L2 U (M2) U' L2 U

We can also develop methods for solving corners that are similar to M2. Some blindsolvers use R2 or D2 to swap corners, resulting in an M2/R2 or M2/D2 blindsolving method. However, these methods introduce many more complications.⁴ Most experienced blindsolvers move from M2/OP directly to 3-style, opting to use M2/3-style corners. That is why I choose to stick with OP corners.

M2/OP Parity

There is only one parity algorithm we need to know, and it is very simple!

(D' L2 D) M2 (D' L2 D)

Voilà!

1. This begs the question, what about a 2x2x2 Rubik’s cube? Many of the world’s top 2x2x2 solvers memorize large algorithm sets that take care of the last layer in one algorithm. Hence, the speedsolver only has to plan the few steps it takes to solve one layer of a 2x2x2, then visualize/predict the state of the cube afterwards, allowing them to know the algorithm they need to use ahead of time. With enough practice, this could be done in “one look” during inspection time, making the solve essentially a blindsolve. So, the world’s top 2x2x2 solvers typically blindsolve the cube during competitions and full-speed solves without having to use any blindfolded method. Granted, the corners blindfolded method will work on a 2x2x2, but you can’t expect to achieve times between 1 to 2 seconds with that. ↩

2. Anki is known as a spaced repetition system (SRS) that optimizes review by minimizing required reviews to maintain information in memory. It accomplishes this by using an algorithm to calculated how much time is necessary to test you on a particular “flashcard” right before you are predicted to forget it. However, for the purposes of memorizing something like the Speffz lettering scheme, the SRS aspect is rather unimportant, and Anki is simply used as a flashcard tool. ↩

3. Fun fact: the image I used for the Speffz lettering scheme in this post actually uses this color scheme, which was present in some older online tutorials. Looking in retrospect, this might have caused considerable confusion within that post. ↩

4. Jack Cai made a video explaining the negatives of the R2 corners method and why it is not widely used. ↩