3×3 Blindfold: Lettering, 3-Cycles, and a Complete Solve

Blindfold solving converts the cube’s state into letters, then uses those letters to execute a solution without looking. In the 3-cycle approach used here, each algorithm processes two targets together with a fixed buffer piece. The next letter pair repeats that process for the next two targets.

1. Fix your orientation and lettering

Choose a fixed top and front color and keep that coordinate system throughout memo and execution. U, D, F, B, L, and R name the up, down, front, back, left, and right faces. Each letter in the Speffz diagrams identifies a sticker position: an edge has two letters, and a corner has three.

The heavy outline marks the C buffer position. The corner buffer is UFR (upper front right), and the edge buffer is UF (upper front). Both traces start at the U sticker.

Distinguish a fixed position from a sticker that moves with its piece. For example, edge position D is always the upward-facing slot at UL. The sticker whose solved destination is D is the D sticker. To identify a sticker’s destination, use all two or three colors of its piece together with the fixed center colors.

2. Solve your first 3-cycle

From a solved cube, apply this practice scramble without changing the cube’s overall orientation:

M is the slice between L and R, turning in the same direction as L. Start inspecting the edge buffer C:

Position inspected	Destination of the sticker there	Record
C, the U sticker at UF	D, the U sticker at UL	D
D, the U sticker at UL	B, the U sticker at UR	B
B, the U sticker at UR	C, the buffer	Stop; do not record C

Your edge memo is DB. Execute its algorithm:

The algorithm moves the stickers at the three positions along C→D→B→C, returning these pieces to their destinations. Letter order determines cycle direction; BD and DB are inverse algorithms.

3. Trace the whole cube

Follow a cycle

Start at C, identify the destination letter of the sticker there, record it, and inspect that destination position next. Stop when you encounter any sticker belonging to the buffer piece. Do not record buffer stickers as targets. Observe the cube throughout this process without turning it.

Trace corners and edges as separate strings. When tracing is complete, divide each string into pairs; a pair may cross a cycle boundary. This tutorial memorizes corners first and edges second, then executes edges first and corners second so the longer edge string is used sooner.

Break into an unprocessed cycle

If you return to the buffer while unprocessed pieces remain, choose a sticker on one of those pieces as an entry point. Record the entry letter, then trace from that position. When you reach the entry piece again, record the closing sticker’s letter and end that cycle.

For example, enter at A. The sticker at A belongs at W, and the sticker at W belongs at R. Since R and A are stickers of the same corner, record A W R. This cycle contains two distinct non-buffer corners. The entry and closing letters refer to different stickers of the same piece; the extra entry target connects that cycle to the buffer. Mark whole pieces as processed so another sticker on a processed piece does not become a new entry point.

At the end, every piece should be accounted for: traced, already solved, or in the correct location with the wrong orientation. Record that final category separately as flipped edges or twisted corners.

Parity: pair the final target

A 3-cycle processes two targets at a time. If both raw strings have odd length, append one letter to each string and execute the corresponding combined corner-and-edge swap after the pairs. A legal 3×3 has matching corner and edge permutation parity, so the two raw memo lengths should have the same parity. A mismatch usually indicates a missed piece or a tracing error.

The usual choice is to append B to both strings, then finish with J:

J swaps C/B edges and C/B corners together.

The appended target must belong to a different piece from the last target. If the last target is already on the B piece, choose the alternative below. Use B or D for edges and B or A for corners, then select the matching row.

Edge suffix	Corner suffix	Final parity sequence
B	B	J
D	A	V
D	B	Edge BD algorithm → J → edge DB algorithm
B	A	Edge DB algorithm → V → edge BD algorithm

V swaps C/D edges and C/A corners. Lowercase f turns the front two layers together. BD and DB in the table mean the complete edge algorithms listed below; they are inverses. For even memo lengths, append nothing and skip parity.

Flipped edges and twisted corners

Record pieces that are correctly located but incorrectly oriented separately. Execute the 3-cycles and parity first, then fix these orientations. For an edge, record which piece is flipped. For a corner, also remember which sticker must return to the top or bottom face.

Edges have two orientations, and a legal state has an even total number of flips. If one non-buffer flipped edge remains, it must be flipped together with the buffer edge. Corners have three orientations: their signed twist amounts sum to 0 modulo 3. One clockwise and one counterclockwise twist can cancel; three twists in the same direction also form a legal orientation pattern. Match corner corrections by direction, using the buffer corner to absorb the remaining twist.

4. Reach the basic cases with setups

A setup moves unfamiliar targets to positions whose algorithm you know. Execute the basic algorithm, then undo the setup in reverse order. The setups used here preserve the buffer position. Track each target’s sticker orientation as well as its piece.

For edge memo DV, D is the upward sticker at UL and V is the downward sticker at DR. R2 brings V to B while leaving D and the buffer C fixed, turning the problem into the familiar DB case.

Stage	Action	Effect
Setup	R2	Turns DV into DB
Basic algorithm	M2 U' M U2 M' U' M2	Executes C→D→B→C
Undo setup	R2	Gives the net cycle C→D→V→C

The full algorithm is:

If a setup is L D', its inverse is D L': reverse the order and invert each move. Choose consistent setups for common targets so execution does not require a fresh search each time.

5. Basic algorithm tables

These tables use the UF edge buffer and UFR corner buffer, both starting from sticker C. The edge table covers 24 ordered target pairs on the other three upper-layer edges. The corner table covers 18 ordered target pairs between UBL and DBL. Use setups for other targets.

In standard 3×3 notation, M/E/S turn in the same directions as L/D/F; x/y/z rotate the entire cube 90° in the directions of R/U/F. Lowercase face letters turn the two layers on that side together. An apostrophe reverses a turn, and 2 indicates a half turn.

Adjacent rows are inverse pairs.

Commutators use [A,B] = A B A' B'; conjugates use A:B = A B A'. A and B each represent a move sequence.

Edge algorithms: 24

Corner algorithms: 18

Orientation algorithms

This algorithm flips UF and UB in place:

For another pair, bring the two edges to UF and UB, execute the algorithm, and undo the setup. For UF and DR, use R' B to bring DR to UB, then undo with B' R.

This algorithm twists DFR and DFL in opposite directions without moving any other pieces:

It moves the D-facing sticker of each of these corners onto F. The inverse moves those stickers back to D. Use a rotation or setup to bring the two corners to these positions while tracking their stickers. Execute the inverse of the whole algorithm when the required directions are reversed.

6. A complete solve

Start solved with white on top and green in front. Apply the scramble below, then rotate x2 so yellow is on top and blue in front. Keep that orientation for memo and execution.

Corner memo

From C, trace C→I→C and record I. Break into A: A→W→R. R belongs to the same corner as A, so record A W R; this accounts for two non-buffer corners. Break into L next: L→P→G. G and L belong to the same corner, so record L P G, accounting for two more non-buffer corners.

That covers five non-buffer corners. Add the already solved DBL, the twisted UBR, and the buffer, and all eight corners are accounted for. The raw string has seven letters. Append B and pair it as:

Also remember UBR’s orientation: its B sticker must return from position Q to position B.

Edge memo

Trace from C to obtain P R F Q G T B, then return to the buffer. This cycle contains seven non-buffer edges. Break into D and trace D→W→K→E. E and D belong to the same UL edge, so record D W K E, accounting for three more edges.

Those ten non-buffer edges, the flipped DR edge, and the buffer account for all twelve pieces. The raw string has eleven letters. Append B and pair it as:

Also remember that DR is flipped: its V and O stickers are exchanged.

Execution order and example setups

Order	Execute
1	Edges: PR FQ GT BD WK EB
2	Corners: IA WR LP GB
3	J parity algorithm for the C/B edge and corner swaps
4	Flip UF and DR
5	Correct the UFR and UBR twists

Here is one usable set of setups. For every row, execute “setup → basic algorithm → inverse setup.” A dash means that no setup is needed.

Type	Pair	Setup	Basic pair
edges	PR	L R	MD
edges	FQ	L'	EQ
edges	GT	L2 R'	EB
edges	BD	—	BD
edges	WK	D' L2 R2	BE
edges	EB	—	EB
corners	IA	L'	AS
corners	WR	D	XR
corners	LP	D2 B'	SA
corners	GB	D2 B2	EX

After the 3-cycles and J, every piece is in its correct location. UF and DR remain flipped; UFR and UBR remain twisted. Finish with these complete sequences.

Flip the edges:

Twist the corners:

7. Memorization

For memorization, associate each pair with a word or image, then connect the images into a short scene. Keep the associations stable enough that an image recovers exactly one letter pair. A sound-based memo is another option once tracing and execution are familiar.

The CubeRoot scheme and syllable guide ↗ offers a structured approach to pair memorization.

Further study: lettering and the 818 target pairs

Speffz assigns consecutive letters around each face, making it convenient to compare this tutorial with other English resources. The Chinese version uses the author’s custom scheme. When changing schemes, keep the sticker positions and physical algorithms connected, and translate the target letters consistently.

Once the basic algorithms and setups are fluent, learn direct 3-cycles for frequently used target pairs. With a fixed buffer, there are 21×18=378 ordered corner pairs and 22×20=440 ordered edge pairs: 818 in total.

References

1. ChiChu blindfold tutorial series · Yijiu Shi Yijiusi ↗
2. Solving position and orientation with 3-cycles · ChiChu ↗
3. 18 algorithms with a UFR buffer · Spoon ↗
4. BLDDB · 3-cycle algorithms ↗
5. Jaap’s Puzzle Page · Permutation and orientation constraints ↗
6. CubeRoot · Letter schemes and syllable memo ↗
7. Blindfold training tool ↗