The Roux Method

overview#

roux is a block-building speedsolving method. where CFOP grinds through a solved cross and four algorithmic pair insertions, roux builds two 1x2x3 blocks by intuition, fixes the four remaining corners with a single algorithm, and then finishes the whole cube using nothing but M and U turns. the result is a method with a very low move count (~45-50 STM for speedsolving), essentially zero cube rotations, and a last phase that flows like a drum roll. 𐃏

the solve is held with the two blocks on the left and right of the bottom two layers, so the free M slice runs front to back:

1. first block (FB) — a 1x2x3 block on the down-left: the L centre, the DL, FL and BL edges, and the DFL and DBL corners.
2. second block (SB) — the mirror 1x2x3 block on the down-right, built without disturbing FB. no rotations: everything is done with r, R, U and M.
3. CMLL — orient and permute the four U-layer corners in one algorithm, ignoring everything in the M slice. 42 cases.
4. LSE — the last six edges (UL, UR, UF, UB, DF, DB) with M and U moves only, in three small phases: edge orientation, UL/UR, and the final 4-edge permutation.

the philosophy: corners are expensive to move and cheap to reason about, edges are the reverse. roux spends its intuition budget where algorithms are wasteful (blocks), and its algorithm budget where intuition is slow (corners), then lets the ergonomic M/U finish mop up the edges.

notation#

standard WCA face-turn notation, plus the slice and wide moves that roux leans on. a letter alone is a clockwise quarter turn of that face (looking at the face); a prime (U') is anticlockwise; a 2 is a half turn.

roux is dominated by M, r, R and U. note the direction convention: M pushes the front of the slice down (an L turn), M' pushes it up. the diagrams and algorithms below all assume white on the bottom and yellow on top at the end of second block, with the last-layer colour yellow.

step 1: first block#

the first block is solved by inspection and intuition — there is no algorithm set, and that is the point. a 1x2x3 block is three edges and two corners around a centre; the useful decompositions are:

• square + pair: build the 1x2x2 “square” (centre, DL edge, one corner-edge pair) then attach the remaining corner-edge pair.
• three pairs: DL edge with the centre, then two corner-edge pairs inserted around it.

practical guidance rather than algorithms:

• solve it on the bottom-left without rotating; learn to build it with the left hand’s L, l and the right hand’s r, R, M while the block sits at DL.
• keyhole liberally: while the second block is empty, the DR area is a free working slot — pieces can pass through it at no cost.
• pair pieces before placing them: get a corner and edge “one move from joined”, with the corner’s bottom-colour sticker facing the direction of the joining turn, then join and insert as a unit.
• in inspection, plan the whole block. FB is the only step where full planning is realistic, and it is worth ~10 moves.

step 2: second block#

the second block is the same 1x2x3 built at down-right, with the constraint that FB must survive. this restricts you to R, r, U and M — which is exactly why roux needs no rotations.

the modern standard is DR first: solve the DR edge (with the centre aligned) or the full 1x2x2 square at back-right, then insert the final corner-edge pair. the workhorse insertions, with the pair staged in the U layer:

the wide versions do the work of a rotation-plus-insert in CFOP without the rotation: r U r' inserts a front pair while dragging the M slice along, which is usually free because the M slice is unsolved until LSE. use M' and M to feed edges up to the U layer where they can be paired.

step 3: CMLL#

after two blocks, the unsolved pieces are the four U-layer corners and the six M-slice/U-layer edges. CMLL solves the corners completely — orientation and permutation at once — while ignoring the edges. this is the algorithmic heart of roux: 42 cases, recognised by corner stickers alone.

recognition#

cases are grouped into eight families by the orientation pattern of the four corners — how many yellow stickers face up, and where the rest point:

• O: all four oriented (top is yellow at the corners); only permutation remains. 2 cases.
• H: none oriented, yellow side-stickers in two opposite pairs. 4 cases.
• Pi: none oriented, the other pattern. 6 cases.
• U: two adjacent oriented, the misoriented pair’s yellows face the same way. 6 cases.
• T: two adjacent oriented, the misoriented pair’s yellows face opposite ways. 6 cases.
• L: two diagonal corners oriented. 6 cases.
• S (sune): one oriented, the other three sharing a twist direction — the family solved by the classic sune R U R' U R U2 R'. 6 cases.
• AS (anti-sune): the mirror — one oriented, the other three twisted the opposite way. 6 cases.

within a family, the case is pinned down by the side-sticker pattern — headlights (two stickers of the same colour on one face), bars, and diagonals.

every diagram below is generated mechanically: a cube simulator applies the inverse of the printed algorithm to a solved cube and reads off the exact sticker colours, so diagram and algorithm cannot disagree. grey stickers are edges the case does not care about. AUF (adjust U face) so your corners match the diagram, apply the algorithm, and the corners are done. 𐃏

O: oriented corners#

the lucky family: corners already oriented, possibly permuted. skip if all four are also permuted (roughly 1 in 6 solves after the diagonal/adjacent split).

H: no corners oriented, opposite pairs#

Pi: no corners oriented#

U: two adjacent oriented#

T: two adjacent oriented#

L: two diagonal oriented#

S: sune family#

AS: anti-sune family#

step 4: LSE — the last six edges#

six edges remain: UL, UR, UF, UB, DF, DB, plus possibly offset centres. everything from here is M and U turns. LSE is conventionally split into 4a (orient), 4b (UL/UR), 4c (permute the rest).

4a: edge orientation#

an edge is misoriented (“bad”) when its yellow-or-white sticker does not face up or down. misoriented edges always come in even counts: 0, 2, 4 or 6 of them. the fundamental primitive is the arrow: M' U' M solves the state with UF, UL, UR and DF all bad — three bad edges on top pointing at a fourth on the bottom — and every other case is a few setup moves away from an arrow.

each row below names the exact set of bad edge positions it solves; these were derived mechanically by running the inverse of each algorithm through the same cube simulator that draws the CMLL diagrams.

with a little practice you stop memorising and start steering — every case reduces to setting up an arrow. 𐃏

4b: UL and UR#

place the two side edges UL and UR, completing the left and right layers. this is recognition-driven rather than algorithmic: bring both edges into the M slice or the U layer, pair them at top or bottom, and drop them in with M2 or M U2 M'-style insertions. the two staple patterns:

• both edges at the bottom, correctly opposed: AUF, then M2 places both.
• one up, one down: U M' U2 M-style setups pair them, then insert.

after 4b the L and R faces are solid, and only the four M-slice edges (and possibly the centres) remain.

4c: the last four edges#

AUF so UF/UB match the centres, then one of four named permutations (or their easy compositions) ends the solve:

recognition trick: track DF and DB through 4b. if you know where the two bottom edges are going, the whole of 4c is decided before it starts.

references#

• speedsolving wiki: roux method — the canonical overview and history.
• kian mansour’s roux guide — the CMLL algorithm set used here, plus EOLR.
• dan’s cubing cheat sheet: CMLL and cubingapp CMLL — the two sources the algorithms were cross-checked against.
• rouxers.com tutorial — block-building and LSE walkthroughs.
• the CTAN rubik bundle — the LaTeX package drawing the diagrams in the PDF export of this page.