CFOP OLL

Case recognition

• OLL Solved

  OLL is already solved.

  OLL is already solved.

  OLL is already solved. Continue to PLL.

• Dot — Two-stage edge flip

  Orient all top stickers from the dot shape (zero edges up) with a two-stage edge-flip separated by a built-in U2.

  Construct the OLL-01 state.

  From the dot with no edges and all four corners misoriented in the two-stage-flip arrangement, trigger the two-stage flip (OLL-01).

  Zero edges oriented (dot shape) and zero corners oriented — the whole top face shows no U-color edge stickers and no U-color corner stickers. This is the fullest dot pattern; it fires the two-stage flip.

  No U-color edge stickers anywhere on top (the dot tell) and no U-color corner stickers either — every top cubie points sideways.

  AUF to match the corner pattern to the algorithm's start; the U2 between the two flip stages is built into the formula.

  Two-stage flip: R U2 R2 F R F' manipulates the corners while flipping one edge pair, U2 repositions the top, then R' F R F' flips the remaining pair. Feel the U2 as the handoff between the two stages.

  Feel the U2 midpoint as the handoff between the two flip stages — it is your one checkpoint in an otherwise continuous formula.

  First stage

  R U2 R2 F R F' works the corners and flips the first pair of edges U-up, breaking the dot.

  U2

  U2 rotates the top 180° to bring the remaining edge pair into position for the second flip.

  Second stage

  R' F R F' opens the F face, flips the remaining edge pair, and closes — finishing the top.

  AUF {netAlign}

  Rotate U to the algorithm's starting angle.

  Rotate U to match the algorithm's starting angle.

  AUF adjust

  Rotate the U layer so the top pattern lines up with the algorithm's start angle.

• Dot — Standard flip then wide flip

  Orient all top stickers from the dot shape (zero edges up) with a standard edge-flip followed by a wide-layer flip.

  Construct the OLL-02 state.

  From the dot with no edges up, trigger the standard-then-wide flip (OLL-02).

  Zero edges oriented (dot shape). The whole top face shows no U-color edge stickers; this case fires the familiar edge-flip trigger twice at different widths.

  No U-color edge stickers anywhere on top — the defining dot tell. The corner configuration picks this case over the other dot variants.

  AUF to match the corner pattern. After the first flip the top shows an L-shape — that is expected, not a mistake.

  Standard flip F R U R' U' F' first (opens the F door, inserts the corner, closes — flipping one edge pair), then the wide flip f R U R' U' f' — identical except f turns two layers. Feel the extra width on the second trigger.

  The only difference between the two halves is the layer width — drill the transition so your right hand knows when to widen.

  Flip edges

  Standard edge-flip trigger F R U R' U' F': opens the F face, inserts the corner, closes — flipping one pair of edges U-up.

  Wide flip

  Wide-layer flip f R U R' U' f': same trigger with a two-layer f, flipping the remaining edge pair to finish the top.

  AUF {netAlign}

  Rotate U to the algorithm's starting angle.

  Rotate U to match the algorithm's starting angle.

  AUF adjust

  Rotate the U layer so the top pattern lines up with the algorithm's start angle.

• Dot — Wide flip, U', then standard flip

  Orient all top stickers from the dot shape (zero edges up) with a wide-layer flip first, a U' adjustment, then a standard flip.

  Construct the OLL-03 state.

  From the dot with one corner up, trigger the wide-then-standard flip with a U' handoff (OLL-03).

  Zero edges oriented (dot shape) with exactly one corner oriented up. The single U-color corner sticker separates this from OLL-02 (no corners); its position picks the U' bridge over OLL-04's U.

  No U-color edge stickers anywhere on top, plus exactly one U-color corner sticker pointing up.

  AUF so the wide flip starts from the correct angle; the U' between the two halves is critical — do not skip it.

  Wide flip f R U R' U' f' first (flips one edge pair), U' repositions the top, then standard flip F R U R' U' F' flips the remaining pair. This is OLL-02's triggers reversed, bridged by a U' instead of nothing — the corner count tells you which case you are in.

  OLL-03 and OLL-04 share the same two triggers — only the corner's position tells you whether to bridge with U' (OLL-03) or U (OLL-04).

  Wide flip

  Wide-layer flip f R U R' U' f': two-layer f opens and closes, flipping the first pair of edges U-up.

  U'

  U' rotates the top one notch counterclockwise to align the remaining edge pair for the second flip.

  Standard flip

  Standard edge-flip F R U R' U' F' flips the remaining edge pair and finishes the top.

  AUF {netAlign}

  Rotate U to the algorithm's starting angle.

  Rotate U to match the algorithm's starting angle.

  AUF adjust

  Rotate the U layer so the top pattern lines up with the algorithm's start angle.

• Dot — Wide flip, U, then standard flip

  Orient all top stickers from the dot shape (zero edges up) with a wide-layer flip, a U adjustment, then a standard flip.

  Construct the OLL-04 state.

  From the dot with one corner up, trigger the wide-then-standard flip with a U handoff (OLL-04).

  Zero edges oriented (dot shape) with exactly one corner oriented up. Same triggers as OLL-03, but the corner sits on the opposite side, so the bridging move is U instead of U'.

  No U-color edge stickers anywhere on top, plus exactly one U-color corner sticker pointing up.

  AUF so the wide flip has the correct starting geometry; the U between halves aligns the second flip.

  Wide flip f R U R' U' f' first, U repositions the top, then standard flip F R U R' U' F' finishes. Identical to OLL-03 except the bridge is U (clockwise) instead of U' — check the corner before committing so you fire the right one.

  Wide flip

  Wide-layer flip f R U R' U' f': two-layer f opens and closes, flipping the first pair of edges U-up.

  U

  U rotates the top one notch clockwise to align the remaining edge pair for the second flip.

  Standard flip

  Standard edge-flip F R U R' U' F' flips the remaining edge pair and finishes the top.

  AUF {netAlign}

  Rotate U to the algorithm's starting angle.

  Rotate U to match the algorithm's starting angle.

  AUF adjust

  Rotate the U layer so the top pattern lines up with the algorithm's start angle.

• Dot — Corner control with edge-flip finish

  Orient all top stickers from the dot shape (zero edges up) by combining a sune-style corner opener with a two-stage edge-flip finish.

  Construct the OLL-17 state.

  From the dot with two corners up and no matching side pair, trigger the sune-into-flip formula (OLL-17).

  Zero edges oriented (dot shape) with exactly two corners oriented up and no same-color side pair (no headlights). The two U-color corner stickers plus the empty edge ring signal the composite R U R' U... formula rather than a pure two-flip.

  No U-color edge stickers anywhere on top, with two U-color corner stickers pointing up.

  AUF so the R-layer opening starts from the correct angle; no cube rotation is needed.

  The first half R U R' U R' F R F' combines corner insertion with an edge flip, U2 resets the top, then R' F R F' flips the remaining pair. The R' F R F' closer is the same reusable block as OLL-01's second stage.

  Read the opener R U R' U R' F R F' as the sune opening (R U R' U) flowing straight into the flip trigger R' F R F' — chain it as one motion.

  Corner opener

  R U R' U R' F R F' repositions the corners and flips one edge pair, breaking the dot into a workable shape.

  U2

  U2 rotates the top 180° to set up the closing flip on the remaining edge pair.

  Edge-flip finish

  R' F R F' opens the F face, flips the remaining edge pair, and closes to finish the top.

  AUF {netAlign}

  Rotate U to the algorithm's starting angle.

  Rotate U to match the algorithm's starting angle.

  AUF adjust

  Rotate the U layer so the top pattern lines up with the algorithm's start angle.

• Dot — With cube rotation

  Orient all top stickers from the dot shape (zero edges up) with a formula that rotates the whole cube partway through.

  Construct the OLL-18 state.

  From the dot with two corners up and a matching side pair (headlights), trigger the rotation-included formula (OLL-18).

  Zero edges oriented (dot shape) with exactly two corners oriented up and a clear pair of same-color side stickers (headlights) on one face. That matching side pair marks this as the rotation case rather than OLL-17's no-headlights version.

  No U-color edge stickers anywhere on top, two U-color corners up, and a same-color side pair on one face.

  AUF so the opening F R U R' U aligns; be ready for the y' cube rotation midway through.

  F R U R' U opens the F door and adjusts the corners, then y' rotates the whole cube before R' U2 R' F R F' finishes the flip. The rotation is why this case feels longer than other dots — practice the y' regrip until it is a single motion.

  The y' regrip is the only hard part — keep both hands light through F R U R' U so you are free to rotate the cube cleanly at y'.

  Open and adjust

  F R U R' U opens the F face and repositions the corners to set up the rotation.

  Rotate and finish

  y' rotates the whole cube a quarter turn (note the new front face), then R' U2 R' F R F' flips the edges to finish the top.

  AUF {netAlign}

  Rotate U to the algorithm's starting angle.

  Rotate U to match the algorithm's starting angle.

  AUF adjust

  Rotate the U layer so the top pattern lines up with the algorithm's start angle.

• Dot — M-slice edge control

  Orient all top stickers from the dot shape (zero edges up) using an M-slice opener that slides the middle stripe while inserting a corner, then an edge-flip finish.

  Construct the OLL-19 state.

  From the dot with two corners up and no matching side pair, trigger the M-slice-into-flip formula (OLL-19).

  Zero edges oriented (dot shape) with two corners up and no same-color side pair (no headlights). The M-slice opening — sliding the center column — separates this from the R-layer dot cases.

  No U-color edge stickers anywhere on top, two U-color corners up, and no same-color side pair on any face.

  AUF so the M-slice opening aligns with the edge that needs sliding; keep a middle finger ready for M moves.

  M U R U R' U' M' slides the middle column while a corner insertion (R U R' U') happens between the M and M', then R' F R F' flips the remaining edges to finish.

  M and M' are opposite directions — drill the M U ... M' frame so the slice opens and closes cleanly around the R U R' U' insert.

  M-slice opener

  M U R U R' U' M' slides the middle column (M), inserts a corner (R U R' U'), and closes the slice (M') — flipping and repositioning edges.

  Edge-flip finish

  R' F R F' opens the F face, flips the remaining edge pair, and closes to finish the top.

  AUF {netAlign}

  Rotate U to the algorithm's starting angle.

  Rotate U to match the algorithm's starting angle.

  AUF adjust

  Rotate the U layer so the top pattern lines up with the algorithm's start angle.

• Dot — M-slice into wide-layer finish

  Orient all top stickers from the dot shape (zero edges up) when the corners are already solved, using an M-slice opener and a wide-layer finish.

  Construct the OLL-20 state.

  From the dot with all four corners already up, trigger the M-slice-into-wide-finish formula (OLL-20).

  Zero edges oriented (dot shape) but all four corners already oriented up. This is the rare dot where only the edges need flipping — the full ring of U-color corner stickers around an empty edge ring is the signature.

  All four U-color corner stickers pointing up, but no U-color edge stickers anywhere — a dot with a solved corner ring.

  AUF so the M-slice opening works from the current angle; the M2 and r' at the end both move two layers.

  M U R U R' U' M2 does the bulk — an M-slice slide, an R U R' U' insert, and a double M2 — then U R U' r' closes with a wide-layer r'. Both M2 and r' turn two layers, so the ending is all wide moves.

  Because the corners start solved, your only real job is the edges — trust the M-slice to move them and keep the corner ring steady in mind.

  M-slice opener

  M U R U R' U' M2 slides the middle column (M), runs a corner insert (R U R' U'), then a double slice slide (M2) — moving the edges into the position the closer needs.

  Wide-layer finish

  U R U' r' does a U regrip then a wide-layer r' (two-layer R') that flips the last edges and completes the top.

  AUF {netAlign}

  Rotate U to the algorithm's starting angle.

  Rotate U to match the algorithm's starting angle.

  AUF adjust

  Rotate the U layer so the top pattern lines up with the algorithm's start angle.

• Square — Left wide-layer sweep

  Orient all top stickers from the L-shape (two adjacent edges up) with one corner up — the edges and corner fill one quadrant into a small square — a same-color block, and no headlights, firing a single left wide-layer sweep.

  Construct the OLL-05 state.

  From the square with a block but no headlights at the left wide-layer angle, trigger the left wide sweep (OLL-05).

  Two adjacent edges oriented (an L) with one corner up — the three oriented stickers fill one corner of the top face into a small square — a same-color block, and no headlights. The l' wide-layer opener on the left is the tell for this side.

  An L of U-color edge stickers plus one U-color corner sticker filling the corner between them into a small square, with a same-color block on a side face but no headlights.

  AUF so the l' wide-layer opener aligns with the square's orientation.

  l' U2 L U L' U l opens two left layers (wide), runs a single-layer L U L' U corner adjustment around a U2 in the middle, and closes. The l and l bookend the whole sequence — keep the inner and outer left layers turning together.

  l is the left twin of r — two layers turn together, not one; feel the wide frame open and close.

  Left wide-layer sweep

  l' opens two left layers, the U2 and single-layer L U L' U twist the corners, and l closes — finishing the cross and the top.

  AUF {netAlign}

  Rotate U to the algorithm's starting angle.

  Rotate U to match the algorithm's starting angle.

  AUF adjust

  Rotate the U layer so the top pattern lines up with the algorithm's start angle.

• Square — Right wide-layer sweep

  Orient all top stickers from the L-shape (two adjacent edges up) with one corner up — the edges and corner fill one quadrant into a small square — a same-color block, and no headlights, firing a single right wide-layer sweep, the mirror of OLL-05.

  Construct the OLL-06 state.

  From the square with a block but no headlights at the right wide-layer angle, trigger the right wide sweep (OLL-06).

  Two adjacent edges oriented (an L) with one corner up filling one quadrant into a small square, a same-color block, and no headlights — the right-hand mirror of OLL-05. The r wide-layer opener on the right is the tell.

  An L of U-color edge stickers plus one U-color corner sticker filling the corner into a small square, with a same-color block on a side but no headlights — the mirror of OLL-05.

  AUF so the r wide-layer opener aligns with the square's orientation.

  r U2 R' U' R U' r' opens two right layers (wide), runs single-layer R' U' R U' corner work around a U2 in the middle, and closes — the mirror of OLL-05. Every move is the right-hand counterpart.

  Mirror of OLL-05 — if you know the left sweep, reflect it; r is two right layers together, R is one.

  Right wide-layer sweep

  r opens two right layers, the U2 and single-layer R' U' R U' twist the corners, and r' closes — finishing the cross and the top.

  AUF {netAlign}

  Rotate U to the algorithm's starting angle.

  Rotate U to match the algorithm's starting angle.

  AUF adjust

  Rotate the U layer so the top pattern lines up with the algorithm's start angle.

• Small Lightning — Wide-layer Sune

  Orient all top stickers from the L-shape (two adjacent edges up) with the single corner up and a same-color block, wrapping a whole Sune inside right wide-layer bookends.

  Construct the OLL-07 state.

  From the small-lightning L with the lone corner at the wide-layer angle, trigger the wide-layer Sune (OLL-07).

  Two adjacent edges oriented (L-shape) with exactly one corner up, a same-color block, and no headlights. The lone corner sits at the angle that fires the r opener — this is the only small-lightning case solved by a single wide-layer Sune.

  An L of U-color edge stickers in one corner of the top face plus a single U-color corner sticker, together tracing a small lightning bolt.

  AUF so the lone corner points to the right wide-layer opening; prepare the r wrist widen.

  r U R' U R U2 r' is a Sune (R U R' U R U2 R') wrapped in right wide-layer bookends (r ... r'). The r and r' open and close two layers each; the Sune core does all the corner work.

  Learn plain Sune first, then add the r/r' wide bookends — the six middle moves are identical to the standalone case.

  Wide-layer Sune

  r U R' U R U2 r' opens the right wide layer, runs a standard Sune in the middle, and closes — the wide bookends are the only difference from plain Sune.

  AUF {netAlign}

  Rotate U to the algorithm's starting angle.

  Rotate U to match the algorithm's starting angle.

  AUF adjust

  Rotate the U layer so the top pattern lines up with the algorithm's start angle.

• Small Lightning — Double-U2 into edge flip

  Orient all top stickers from the L-shape (two adjacent edges up) with the single corner up and a same-color block, swinging the corners with paired U2s and finishing with a standard edge flip.

  Construct the OLL-08 state.

  From the small-lightning L whose corner is set up by paired U2s, trigger the double-U2-into-flip formula (OLL-08).

  Two adjacent edges oriented (L-shape) with exactly one corner up, a same-color block, and no headlights. The paired R U2 R' U2 opener is the tell — it swings the corner into place before the closing flip.

  An L of U-color edge stickers plus a single U-color corner sticker, together tracing a small lightning bolt.

  AUF so the lone corner aligns for the R U2 R' U2 corner swing.

  R U2 R' U2 swings the corners with two back-to-back U2s, then R' F R F' is the standard reusable edge-flip block. The double U2 gives a bouncy rhythm; the closer is a building block shared across many OLLs.

  The closer R' F R F' is the same edge-flip block reused in OLL-33/38/55 — drill it once and reuse it.

  Paired-U2 corner setup

  R U2 R' U2 uses two back-to-back U2s to swing the corner into position for the flip.

  Edge flip

  R' F R F' is the standard reusable edge-flip block, finishing the top.

  AUF {netAlign}

  Rotate U to the algorithm's starting angle.

  Rotate U to match the algorithm's starting angle.

  AUF adjust

  Rotate the U layer so the top pattern lines up with the algorithm's start angle.

• Small Lightning — Left flip, rotate, right flip

  Orient all top stickers from the L-shape (two adjacent edges up) with the single corner up and a same-color block, doing a left-hand flip, a cube rotation, then a right-hand flip.

  Construct the OLL-11 state.

  From the small-lightning L that needs a left flip followed by a rotated right flip, trigger the flip-rotate-flip formula (OLL-11).

  Two adjacent edges oriented (L-shape) with exactly one corner up, a same-color block, and no headlights. This case pairs a left-hand flip with a rotated right-hand flip — the F' ... F opener marks the left-handed first half.

  An L of U-color edge stickers plus a single U-color corner sticker, together tracing a small lightning bolt.

  AUF so the F' opener reads cleanly; be ready for the y rotation midway.

  F' L' U' L U F is a left-hand edge flip, then y rotates the whole cube a quarter turn, then F R U R' U' F' is the standard right-hand flip from the new front. The rotation is the only thing separating this from a plain double flip.

  Both halves are the same flip formula mirrored across the F axis — only the y rotation between them is new.

  Left-hand flip

  F' L' U' L U F opens the front face left-handed, inserts the corner, and closes — a mirror-image edge flip.

  Rotated right-hand flip

  y rotates the cube a quarter turn (note the new front face), then F R U R' U' F' is the standard right-hand edge flip from the new angle.

  AUF {netAlign}

  Rotate U to the algorithm's starting angle.

  Rotate U to match the algorithm's starting angle.

  AUF adjust

  Rotate the U layer so the top pattern lines up with the algorithm's start angle.

• Small Lightning — Doubled beginner flip

  Orient all top stickers from the L-shape (two adjacent edges up) with the single corner up and a same-color block, applying the standard beginner edge flip twice with a U in between.

  Construct the OLL-12 state.

  From the small-lightning L solved by repeating the beginner flip, trigger the doubled-flip formula (OLL-12).

  Two adjacent edges oriented (L-shape) with exactly one corner up, a same-color block, and no headlights. Solved by the beginner edge-flip formula applied twice with a U between — the simplest of the four.

  An L of U-color edge stickers plus a single U-color corner sticker, together tracing a small lightning bolt.

  AUF so the first flip targets the correct edge pair.

  F R U R' U' F' twice with a U between them. It is the beginner edge-flip formula repeated — easy to learn, and the small U in the middle is essential, not optional.

  If you know the beginner flip, you know this case: do it, U, do it again.

  First edge flip

  F R U R' U' F' is the beginner edge-flip formula, flipping one edge pair.

  U adjustment

  U re-aligns the top so the second flip targets the remaining edge pair.

  Second edge flip

  F R U R' U' F' repeats the same flip formula to finish the top.

  AUF {netAlign}

  Rotate U to the algorithm's starting angle.

  Rotate U to match the algorithm's starting angle.

  AUF adjust

  Rotate the U layer so the top pattern lines up with the algorithm's start angle.

• Fish — Classic one-head fish

  Orient all top stickers from the L-shape (two adjacent edges up) with exactly one corner up — the classic one-head fish silhouette.

  Construct the OLL-09 state.

  From the one-corner fish whose head sits front-right and edge-L sits back-left, trigger the classic fish (OLL-09).

  Two adjacent edges oriented (L-shape) with exactly one corner up, a same-color block, and no headlights. The single U-color corner (the fish head) sits diagonally across from the corner of the edge-L; this one has the head front-right, which separates it from OLL-10's rotated mirror.

  An L of U-color edge stickers with one U-color corner sticker diagonally opposite the L's corner, plus a same-color block on a side.

  AUF so the fish head points front-right; the sexy-move opening R U R' U' reads from there.

  R U R' U' (a sexy move) sets the corner, then R' F R2 U R' U' F' opens the F door, flips the edges with an R2 pivot, and closes. The R2 inside the second half is the pivot point.

  The first four moves are a plain sexy move — get the single corner placed before the F-door finish does the edge work.

  Sexy-move set

  R U R' U' is a standard sexy-move insertion that repositions the single oriented corner ahead of the finish.

  F-door edge finish

  R' F R2 U R' U' F' opens the F face, pivots on R2, flips the remaining edges, and closes to finish the top.

  AUF {netAlign}

  Rotate U to the algorithm's starting angle.

  Rotate U to match the algorithm's starting angle.

  AUF adjust

  Rotate the U layer so the top pattern lines up with the algorithm's start angle.

• Fish — Rotated mirror with sune-style opener

  Orient all top stickers from the L-shape (two adjacent edges up) with exactly one corner up — the rotated mirror of the classic fish.

  Construct the OLL-10 state.

  From the one-corner fish whose head sits back-right and edge-L sits front-left, trigger the rotated-mirror fish (OLL-10).

  Two adjacent edges oriented (L-shape) with exactly one corner up, a same-color block, and no headlights — the rotated mirror of OLL-09. The fish head sits back-right here (OLL-09's is front-right), so the opening trigger changes to R U R' U R' F R F'.

  An L of U-color edge stickers with one U-color corner sticker diagonally opposite the L's corner, plus a same-color block on a side.

  AUF so the fish head points back-right; the sune-style opening reads from there.

  The opener R U R' U R' F R F' flows the corner insertion straight into an edge flip (R' F R F'), then R U2 R' finishes. The whole first chunk is one continuous motion — the top changes fast, so do not look away.

  Read R U R' U R' F R F' as the sune opening (R U R' U) chaining into the flip trigger R' F R F' — one motion, not two.

  Sune-into-flip opener

  R U R' U R' F R F' chains a corner insertion into an edge-flip trigger, repositioning corners and flipping one edge pair.

  Double-turn finish

  R U2 R' brings the last corner U-up with a double turn to finish the top.

  AUF {netAlign}

  Rotate U to the algorithm's starting angle.

  Rotate U to match the algorithm's starting angle.

  AUF adjust

  Rotate the U layer so the top pattern lines up with the algorithm's start angle.

• Fish — Two-corner double-U2

  Orient all top stickers from the L-shape (two adjacent edges up) with two corners up on a diagonal.

  Construct the OLL-35 state.

  From the two-corner fish with a diagonal corner pair and no block, trigger the double-U2 fish (OLL-35).

  Two adjacent edges oriented (L-shape) with exactly two corners up on a diagonal, no headlights, and no block. The diagonal corner pair plus the missing block separate this from OLL-37 (which has a block) and from OLL-09/10 (one corner).

  An L of U-color edge stickers with two U-color corner stickers on a diagonal and no same-color block on any side.

  AUF so the opening R U2 starts from the correct side.

  R U2 R2 F R F' flips the edges with a doubled U2/R2 rhythm, then R U2 R' finishes the corners. The two U2 turns give it a wave-like cadence; it shares the R U2 R skeleton with OLL-01's opener but lands shorter.

  Feel the two U2 turns as the spine of the formula — one opens the flip, one closes the corners.

  Double-rhythm flip

  R U2 R2 F R F' works the corners and flips the edge pair with a doubled U2/R2 rhythm.

  Corner finish

  R U2 R' brings the remaining corners U-up with a second U2 to finish the top.

  AUF {netAlign}

  Rotate U to the algorithm's starting angle.

  Rotate U to match the algorithm's starting angle.

  AUF adjust

  Rotate the U layer so the top pattern lines up with the algorithm's start angle.

• Fish — Self-contained F-wrap

  Orient all top stickers from the L-shape (two adjacent edges up) with two corners up on a diagonal, in a single F-door wrap.

  Construct the OLL-37 state.

  From the two-corner fish with a diagonal corner pair plus a block, trigger the self-contained F-wrap (OLL-37).

  Two adjacent edges oriented (L-shape) with exactly two corners up on a diagonal, no headlights, and a same-color block. The block is what picks this over OLL-35; the clean F-door frame is the tell.

  An L of U-color edge stickers with two U-color corner stickers on a diagonal and a same-color block on a side.

  AUF so the F opening operates on the correct face.

  F R U' R' U' R U R' F' is completely self-contained — the F opens, the corner work happens inside, the F' closes. No splits, no rotations; the F ... F' bookends are the whole formula.

  Because the whole thing sits inside one F-door, treat it as a single trigger — drill the F ... F' frame so the inside flows without a regrip.

  F-door wrap

  F R U' R' U' R U R' F' opens the F face, twists the corners inside the frame, and closes to finish the top.

  AUF {netAlign}

  Rotate U to the algorithm's starting angle.

  Rotate U to match the algorithm's starting angle.

  AUF adjust

  Rotate the U layer so the top pattern lines up with the algorithm's start angle.

• Knight Move — Front-left corner, wide-layer + rotation

  Orient all top stickers from the line shape (two opposite edges up) with the single corner up at front-left, finishing with right wide-layer work and a cube rotation.

  Construct the OLL-13 state.

  From the knight-move line with the lone corner at front-left, trigger the wide-layer-then-rotate formula (OLL-13).

  Two opposite edges oriented (a horizontal line across the middle) with exactly one corner up at front-left, a same-color block, and no headlights. The corner's position is the only thing that separates the four knight-move cases — front-left here fires the right wide-layer opener.

  A horizontal line of U-color edge stickers across the top middle, plus a single U-color corner sticker at front-left — the knight's-move L.

  AUF so the lone corner sits front-left before starting; prepare for the y' rotation in the second half.

  The first half r U' r' U' r U r' is entirely right wide-layer work, then y' rotates the whole cube so R' U R finishes. Keep wide (r, two layers) and narrow (R, one layer) distinct.

  The four r/r' moves are two open-close pairs — drill the wrist widen so each r clearly lifts two layers.

  Right wide-layer work

  r U' r' U' r U r' opens and closes the right wide layer twice with U' turns between, twisting the corners into position.

  Rotate and finish

  y' rotates the whole cube a quarter turn (note the new front face), then R' U R finishes the top.

  AUF {netAlign}

  Rotate U to the algorithm's starting angle.

  Rotate U to match the algorithm's starting angle.

  AUF adjust

  Rotate the U layer so the top pattern lines up with the algorithm's start angle.

• Knight Move — Front-right corner, F-layer + rotation

  Orient all top stickers from the line shape (two opposite edges up) with the single corner up at front-right, finishing with F-layer work and a cube rotation.

  Construct the OLL-14 state.

  From the knight-move line with the lone corner at front-right, trigger the F-layer-then-rotate formula (OLL-14).

  Two opposite edges oriented (a horizontal line across the middle) with exactly one corner up at front-right, a same-color block, and no headlights. The corner at front-right (mirror of OLL-13's front-left) fires the R' F R F-layer opener.

  A horizontal line of U-color edge stickers across the top middle, plus a single U-color corner sticker at front-right — the knight's-move L.

  AUF so the lone corner sits front-right before starting.

  R' F R U R' F' R opens and closes the F face while flipping an edge, then y' rotates the cube and R U' R' finishes. The R' F R ... F' core is the building block — it mirrors OLL-13's wide-layer shape in single-layer F moves.

  The R' F R triple at the open and the R F' at the close share the F axis — keep the wrist light through the F-door so the y' regrip stays clean.

  F-layer edge work

  R' F R U R' F' R works through the F face, flipping an edge and repositioning the corners.

  Rotate and finish

  y' rotates the whole cube a quarter turn (note the new front face), then R U' R' finishes the top.

  AUF {netAlign}

  Rotate U to the algorithm's starting angle.

  Rotate U to match the algorithm's starting angle.

  AUF adjust

  Rotate the U layer so the top pattern lines up with the algorithm's start angle.

• Knight Move — Back-left corner, three left wide passes

  Orient all top stickers from the line shape (two opposite edges up) with the single corner up at back-left, finishing with three left wide-layer passes around a single-layer core.

  Construct the OLL-15 state.

  From the knight-move line with the lone corner at back-left, trigger the three-left-wide-pass formula (OLL-15).

  Two opposite edges oriented (a horizontal line across the middle) with exactly one corner up at back-left, a same-color block, and no headlights. The corner at back-left (left side) fires the l-heavy left-wide-layer formula — the left mirror of OLL-16.

  A horizontal line of U-color edge stickers across the top middle, plus a single U-color corner sticker at back-left — the knight's-move L.

  AUF so the lone corner sits back-left before starting; keep left-hand wide (l) and narrow (L) layers distinct.

  Three wide passes — l' U' l, then L' U' L U, then l' U l — sandwich a single-layer L sequence between two wide-layer pairs. Don't confuse l (two layers) with L (one layer); the three-pass structure gives a wave-like rhythm.

  Read it as wide-narrow-wide: two l-passes around one L-pass in the middle — that is the whole shape.

  First wide pass

  l' U' l opens the left wide layer, runs a U' adjustment, and closes.

  Single-layer insert

  L' U' L U is a single-layer left insertion that fine-tunes the corner positions.

  Closing wide pass

  l' U l opens the left wide layer again and closes to finish the top.

  AUF {netAlign}

  Rotate U to the algorithm's starting angle.

  Rotate U to match the algorithm's starting angle.

  AUF adjust

  Rotate the U layer so the top pattern lines up with the algorithm's start angle.

• Knight Move — Back-right corner, right wide with insertion

  Orient all top stickers from the line shape (two opposite edges up) with the single corner up at back-right, finishing with right wide passes around a standard insertion.

  Construct the OLL-16 state.

  From the knight-move line with the lone corner at back-right, trigger the right-wide-with-insertion formula (OLL-16).

  Two opposite edges oriented (a horizontal line across the middle) with exactly one corner up at back-right, a same-color block, and no headlights. The corner at back-right (right side) fires the r-heavy right-wide-layer formula — the right mirror of OLL-15.

  A horizontal line of U-color edge stickers across the top middle, plus a single U-color corner sticker at back-right — the knight's-move L.

  AUF so the lone corner sits back-right before starting; keep right-hand wide (r) and narrow (R) layers distinct.

  r U r' opens, R U R' U' is a standard sexy-move insertion in the middle, r U' r' closes. The alternation between wide (r) and narrow (R) is the finger-trick challenge — it is OLL-15 mirrored, every l becomes r, every L becomes R.

  If you know OLL-15, mirror it: every left move becomes its right-hand twin, and the three passes keep the same wide-narrow-wide shape.

  First wide pass

  r U r' opens the right wide layer with a U adjustment and closes.

  Sexy-move insert

  R U R' U' is a standard sexy-move insertion in the middle that repositions the corners.

  Closing wide pass

  r U' r' opens the right wide layer again and closes to finish the top.

  AUF {netAlign}

  Rotate U to the algorithm's starting angle.

  Rotate U to match the algorithm's starting angle.

  AUF adjust

  Rotate the U layer so the top pattern lines up with the algorithm's start angle.

• OCLL — H (double headlights)

  All edges already oriented (cross done); orient the four corners from the H shape — zero corners up with matching side pairs (headlights) on two opposite faces.

  Construct the OLL-21 state.

  From the H with no corners up and headlights on opposite faces, trigger the double-twist formula (OLL-21).

  All four edges up (cross) and zero corners up, with two pairs of same-color side stickers (headlights) on opposite faces. The empty corner ring plus the double headlights marks the H over the Pi (OLL-22, one pair).

  A yellow cross on top with no U-color corner stickers, and matching side pairs (headlights) on both the front and back faces.

  AUF so the two headlights pairs sit on opposite side faces; the formula reads the same whichever way the headlights face.

  R U2 R' U' R U R' U' twists the four corners down into a two-up state, then R U' R' finishes the last two like a mini Anti-Sune. The whole formula is a setup into a Sune-style closer.

  The closing R U' R' is a three-move Anti-Sune fragment — drill formula-1 until you can flow straight into it.

  Twist the four corners

  R U2 R' U' R U R' U' works all four twisted corners, leaving exactly two corners up for the closer.

  Anti-Sune closer

  R U' R' is a three-move Anti-Sune fragment that finishes the last two corners.

  AUF {netAlign}

  Rotate U to the algorithm's starting angle.

  Rotate U to match the algorithm's starting angle.

  AUF adjust

  Rotate the U layer so the top pattern lines up with the algorithm's start angle.

• OCLL — Pi (single headlights)

  All edges already oriented (cross done); orient the four corners from the Pi shape — zero corners up with a single matching side pair (headlights).

  Construct the OLL-22 state.

  From the Pi with no corners up and a single headlights pair, trigger the R2-cascade formula (OLL-22).

  All four edges up (cross) and zero corners up, with exactly one pair of same-color side stickers (headlights). Fewer headlights than the H (OLL-21) marks the Pi.

  A yellow cross on top with no U-color corner stickers, and one matching side pair (headlights) on a single face.

  AUF so the single headlights pair faces left; the cascade starts from there.

  R U2 R2 U' R2 U' R2 U2 R threads three R2 turns through U moves — the R2-U-R2-U-R2 rhythm twists the corner pairs in place, with the opening R and closing R bookending the cascade.

  The whole formula is one continuous R2 cascade — keep your R2 flicks even so the U moves between them stay rhythmic.

  R2 cascade

  R U2 R2 U' R2 U' R2 U2 R threads three R2 turns through U adjustments, twisting all four corners to solved in one continuous cascade.

  AUF {netAlign}

  Rotate U to the algorithm's starting angle.

  Rotate U to match the algorithm's starting angle.

  AUF adjust

  Rotate the U layer so the top pattern lines up with the algorithm's start angle.

• OCLL — U (headlights)

  All edges already oriented (cross done); orient the two twisted corners from the U shape — two corners up with a matching side pair (headlights) between the two unsolved corners.

  Construct the OLL-23 state.

  From the U with two corners up and headlights on the unsolved side, trigger the D-layer formula (OLL-23).

  All four edges up (cross) with two corners up and a matching side pair (headlights) on the face between the two unsolved corners. The headlights plus a solved corner pair is the U.

  A yellow cross on top with two U-color corners up (a solved bar) and matching side stickers (headlights) on the opposite face.

  AUF so the two solved corners sit in back and the headlights face you.

  R2 D R' U2 R D' R' U2 R' uses D and D' to temporarily swing the bottom layer; the D and D' cancel out, so the bottom stays solved. Execute cleanly and ignore the bottom — it restores itself.

  Don't track the bottom during the D moves — they come as a D ... D' pair that returns the first two layers to where they started.

  D-layer corner twist

  R2 D R' U2 R D' R' U2 R' swings the bottom (D), twists the two unsolved corners, and restores it (D') — finishing all four corners.

  AUF {netAlign}

  Rotate U to the algorithm's starting angle.

  Rotate U to match the algorithm's starting angle.

  AUF adjust

  Rotate the U layer so the top pattern lines up with the algorithm's start angle.

• OCLL — T (two adjacent, no headlights)

  All edges already oriented (cross done); orient the two twisted corners from the T shape — two corners up side by side with no matching side pair (no headlights).

  Construct the OLL-24 state.

  From the T with two adjacent corners up and no headlights, trigger the wide-layer formula (OLL-24).

  All four edges up (cross) with two corners up side by side and no matching side pair anywhere. Two adjacent solved corners with no headlights is the T; diagonal solved corners would be the L (OLL-25).

  A yellow cross on top with two U-color corners up side by side, and no matching side stickers on any face.

  AUF so the two solved corners sit on the right; the wide r opening works from there.

  r U R' U' r' is a wide-layer pass that repositions the corners, then F R F' opens and closes the front face to finish. Short and symmetric — two clean segments.

  The wide r and r' turn two layers — keep your right hand wide so the middle slice turns together with the R face.

  Wide-layer pass

  r U R' U' r' does a two-layer r, repositions the corners, and closes — the wide pass sets up the finish.

  F-door finish

  F R F' opens the front face, inserts the corner, and closes — finishing the top.

  AUF {netAlign}

  Rotate U to the algorithm's starting angle.

  Rotate U to match the algorithm's starting angle.

  AUF adjust

  Rotate the U layer so the top pattern lines up with the algorithm's start angle.

• OCLL — L (bowtie)

  All edges already oriented (cross done); orient the two twisted corners from the L (bowtie) shape — two corners up diagonally opposite with no matching side pair (no headlights).

  Construct the OLL-25 state.

  From the L with two corners up diagonally, trigger the front-back symmetric formula (OLL-25).

  All four edges up (cross) with two corners up on opposite (diagonal) corners and no matching side pair anywhere. Diagonal solved corners with no headlights is the bowtie; adjacent solved corners would be the T (OLL-24).

  A yellow cross on top with two U-color corners up on opposite corners, and no matching side stickers on any face.

  AUF so the two solved corners sit on one diagonal; the F and B moves work symmetrically from there.

  R' F R B' works the front, then R' F' R B mirrors it on the back. The front-back symmetry is the memory hook — what you do in front, you mirror in back with B moves.

  The two halves mirror across the F-B axis — drill them as a matched pair so the second half feels like the reflection of the first.

  Front half

  R' F R B' opens the front and back faces, twisting the diagonal corners down into a zero-corner state.

  Back half

  R' F' R B mirrors the front half on the back face, bringing all four corners up to finish.

  AUF {netAlign}

  Rotate U to the algorithm's starting angle.

  Rotate U to match the algorithm's starting angle.

  AUF adjust

  Rotate the U layer so the top pattern lines up with the algorithm's start angle.

• OCLL — Anti-Sune

  All edges already oriented (cross done); orient the three twisted corners from the Anti-Sune shape — one corner up, the lone oriented corner in the Anti-Sune position.

  Construct the OLL-26 state.

  From the Anti-Sune with one corner up, trigger the Anti-Sune formula (OLL-26).

  All four edges up (cross) with exactly one corner up — the classic Anti-Sune. The lone oriented corner sits opposite to the Sune's, giving the 'fish' its mirror pointing.

  A yellow cross on top with a single U-color corner sticker — the Anti-Sune fish pointing the opposite way from the Sune (OLL-27).

  AUF so the single solved corner sits at the Anti-Sune entry position.

  R U2 R' U' is a setup that brings a second corner up, then R U' R' is the Anti-Sune finish. Anti-Sune is the mirror flow of Sune — learn them as a pair.

  If you know Sune (OLL-27), Anti-Sune is its mirror — the same R-handle moves with U' where Sune uses U.

  Setup

  R U2 R' U' repositions the corners, bringing a second corner up to set up the finish.

  Anti-Sune finish

  R U' R' finishes the remaining corners with the Anti-Sune flow.

  AUF {netAlign}

  Rotate U to the algorithm's starting angle.

  Rotate U to match the algorithm's starting angle.

  AUF adjust

  Rotate the U layer so the top pattern lines up with the algorithm's start angle.

• OCLL — Sune

  All edges already oriented (cross done); orient the three twisted corners from the Sune shape — one corner up, the lone oriented corner in the Sune position.

  Construct the OLL-27 state.

  From the Sune with one corner up, trigger the Sune formula (OLL-27).

  All four edges up (cross) with exactly one corner up — the classic Sune. The lone oriented corner sits opposite to the Anti-Sune's, giving the 'fish' its pointing.

  A yellow cross on top with a single U-color corner sticker — the Sune fish pointing the opposite way from the Anti-Sune (OLL-26).

  AUF so the single solved corner sits at the Sune entry position.

  R U R' U is the setup, then R U2 R' is the Sune finish. The most fundamental OLL — build the muscle memory until it is automatic.

  Sune is the backbone of OCLL — once it is automatic, Anti-Sune (OLL-26) and several other cases fall out of it.

  Setup

  R U R' U repositions the corners, holding the single oriented corner in place for the finish.

  Sune finish

  R U2 R' is the Sune finish, bringing all four corners up.

  AUF {netAlign}

  Rotate U to the algorithm's starting angle.

  Rotate U to match the algorithm's starting angle.

  AUF adjust

  Rotate the U layer so the top pattern lines up with the algorithm's start angle.

• H — M-slice edge flip (all corners up)

  Orient all top stickers with all four corners already up and two adjacent edges oriented, plus a same-color bar and headlights, using a pure M-slice edge flip.

  Construct the OLL-28 state.

  From the H-shape with all corners up and a bar on a side, trigger the M-slice flip (OLL-28).

  All four corners already oriented with two adjacent edges up forming an L, plus a same-color bar and headlights. The pure M' U M ... M' U M rhythm (M-slice only, no R/L moves) is the tell — an edge-only case.

  Four U-color corner stickers up with an L of two adjacent U-color edge stickers, plus a same-color bar and headlights on the sides.

  AUF so the M' U M opener aligns with the un-oriented edge pair.

  M' U M U2 M' U M is pure M-slice work — the M' U M pattern repeats with a U2 in the middle. M follows the L-layer direction, so don't confuse M and M'. No R/L moves at all.

  Pure M-slice — keep the M' U M rhythm even and let the U2 reset the second half.

  M-slice flip

  M' U M slides the M slice and flips one pair of edges.

  U2 align

  U2 rotates the top 180° to set up the second edge pair.

  M' U M slides the M slice again to flip the other pair and finish the top.

  AUF {netAlign}

  Rotate U to the algorithm's starting angle.

  Rotate U to match the algorithm's starting angle.

  AUF adjust

  Rotate the U layer so the top pattern lines up with the algorithm's start angle.

• Awkward — M-slice bookend with corner insert

  Orient all top stickers from the L-shape (two adjacent edges up) with two corners up, a same-color block, and no headlights, using an M-slice opening that bookends a corner insertion and an edge flip.

  Construct the OLL-29 state.

  From the awkward L with a block but no headlights at the M-slice angle, trigger the M-bookend formula (OLL-29).

  Two adjacent edges oriented (L-shape) with two corners up, a same-color block on a side, and no headlights. The M-slice opener is the tell — this is the awkward case that leans on the middle slice rather than a face door.

  An L of U-color edge stickers with two U-color corner stickers that don't trace a clean letter, plus a same-color block on a side face but no headlights.

  AUF so the M U opening slides the correct edge into position.

  M U opens the middle slice, R U R' U' inserts a corner, then R' F R F' flips an edge and M' restores the slice. The M and M' bookends must cancel cleanly — keep the middle-slice grip light.

  Read it as M open → corner insert → flip → M' close; the slice bookends frame the whole sequence.

  M-slice open

  M U slides the middle layer and adjusts U, preparing the edge positions for the insertion.

  Corner insert

  R U R' U' is a standard sexy-move insertion that repositions a corner.

  Flip and close

  R' F R F' flips the edge, then M' restores the middle slice and finishes the top.

  AUF {netAlign}

  Rotate U to the algorithm's starting angle.

  Rotate U to match the algorithm's starting angle.

  AUF adjust

  Rotate the U layer so the top pattern lines up with the algorithm's start angle.

• Awkward — Back-face (B) reach

  Orient all top stickers from the L-shape (two adjacent edges up) with two corners up and a full bar plus headlights, reaching around to the back (B) face.

  Construct the OLL-30 state.

  From the awkward L with a bar and headlights at the B-face angle, trigger the back-face formula (OLL-30).

  Two adjacent edges oriented (L-shape) with two corners up and a complete same-color bar plus headlights on a side. The bar marks this over the no-bar awkward case, and the B/B' reach to the back face is the tell.

  An L of U-color edge stickers with two U-color corner stickers that don't trace a clean letter, plus a complete same-color bar and headlights on a side face.

  AUF so the R2 opener starts from the correct side; pre-rotate your wrist for the B' reach before starting.

  R2 U R' B' R U' opens the back face, then R2 U R B R' closes it. The B and B' moves demand a wrist rotation — the only awkward case that reaches the back face.

  Drill the B' reach without losing your right-layer grip; the two R2 turns bookend the back-face work.

  Open the back face

  R2 U R' B' R U' reaches the back face with a wrist rotation and pre-aligns the layers.

  Close the back face

  R2 U R B R' mirrors the opener back, closing the back face and finishing the top.

  AUF {netAlign}

  Rotate U to the algorithm's starting angle.

  Rotate U to match the algorithm's starting angle.

  AUF adjust

  Rotate the U layer so the top pattern lines up with the algorithm's start angle.

• Awkward — U2 pivot then rotate-finish

  Orient all top stickers from the L-shape (two adjacent edges up) with two corners up and headlights, running a U2 pivot in the corner work before a cube rotation closes.

  Construct the OLL-41 state.

  From the awkward L with headlights at the U2-pivot angle, trigger the corner-then-rotate formula (OLL-41).

  Two adjacent edges oriented (L-shape) with two corners up and headlights on a side. The U2 pivot midway through the first half is the key turning point that separates this from the rotate-into-flip awkward case.

  An L of U-color edge stickers with two U-color corner stickers that don't trace a clean letter, plus headlights on a side face.

  AUF so the R U' R' opener aligns correctly; expect the y rotation to change your front face.

  R U' R' U2 R U adjusts the corners with a U2 pivot in the middle, then y R U' R' U' F' rotates the whole cube and finishes. Don't rush the U2 — it is the pivot that sets up the rotation.

  Feel the U2 as the halfway checkpoint; the y rotation then gives a fresh front face for the close.

  Corner work with U2 pivot

  R U' R' U2 R U adjusts the corners, with the U2 in the middle as the key turning point.

  Rotate and finish

  y rotates the whole cube a quarter turn (note the new front face), then R U' R' U' F' finishes the top.

  AUF {netAlign}

  Rotate U to the algorithm's starting angle.

  Rotate U to match the algorithm's starting angle.

  AUF adjust

  Rotate the U layer so the top pattern lines up with the algorithm's start angle.

• Awkward — Corner work then rotate-into-flip

  Orient all top stickers from the L-shape (two adjacent edges up) with two corners up and headlights, doing corner work before a cube rotation into the standard edge flip.

  Construct the OLL-42 state.

  From the awkward L with headlights at the rotate-into-flip angle, trigger the corner-then-flip formula (OLL-42).

  Two adjacent edges oriented (L-shape) with two corners up and headlights on a side — the sibling of OLL-41 that closes with the familiar F R U R' U' F' flip after the rotation. The closing flip is the tell.

  An L of U-color edge stickers with two U-color corner stickers that don't trace a clean letter, plus headlights on a side face.

  AUF so the R' U2 opener starts from the correct side.

  R' U2 R U R' U R handles all the corner work, then y F R U R' U' F' is the beginner edge flip fired from the new angle. The closing flip is the well-known trigger — the rotation just repositions it.

  The closing flip is the beginner trigger in a new orientation; once the corner work is done, let muscle memory finish it.

  Corner work

  R' U2 R U R' U R twists the corners into position, with back-to-back U turns in the middle.

  Rotate and flip

  y rotates the whole cube a quarter turn (note the new front face), then F R U R' U' F' flips the remaining edge to finish the top.

  AUF {netAlign}

  Rotate U to the algorithm's starting angle.

  Rotate U to match the algorithm's starting angle.

  AUF adjust

  Rotate the U layer so the top pattern lines up with the algorithm's start angle.

• P-shape — Front F-door solve

  Orient all top stickers from the L-shape (two adjacent edges up) with two corners up, a same-color block, and no headlights, working the whole solve through the front F-door.

  Construct the OLL-31 state.

  From the P-shape with a block but no headlights at the front-door angle, trigger the F-door formula (OLL-31).

  Two adjacent edges oriented (L-shape) with two corners up, a same-color block, and no headlights. The block sits where the R' U' F opener reaches — the front F-door makes this the short, punchy member of the door pair.

  An L of U-color edge stickers with two U-color corner stickers tracing a P, plus a same-color block on a side face but no headlights.

  AUF so the R' U' F opener aligns with the P's orientation.

  R' U' F opens the F-door, then U R U' R' F' R inserts a corner and closes. Short and punchy — the F and F' bookend the whole algorithm, and everything else happens inside the door.

  Read it as F open → corner insert → F' close; the door frame holds the whole short sequence.

  F-door open

  R' U' F prepares the layers and opens the front face.

  Insert and close

  U R U' R' inserts a corner, then F' R closes the front door and finishes the top.

  AUF {netAlign}

  Rotate U to the algorithm's starting angle.

  Rotate U to match the algorithm's starting angle.

  AUF adjust

  Rotate the U layer so the top pattern lines up with the algorithm's start angle.

• P-shape — Back B-door solve

  Orient all top stickers from the L-shape (two adjacent edges up) with two corners up, a same-color block, and no headlights, working the whole solve through the back B-door.

  Construct the OLL-32 state.

  From the P-shape with a block but no headlights at the back-door angle, trigger the B-door formula (OLL-32).

  Two adjacent edges oriented (L-shape) with two corners up, a same-color block, and no headlights — the mirror of OLL-31 that reaches the back face. The B' ... B pair is the tell that this fires the back door instead.

  An L of U-color edge stickers with two U-color corner stickers tracing a P, plus a same-color block on a side but no headlights — the back-face reach sets it apart.

  AUF so the R U B' opener is reachable; the back-face reach needs a wrist rotation.

  R U B' opens the back face, then U' R' U R B R' closes. It is OLL-31 mirrored onto the back face; the B moves make it slightly harder to execute than the front-door twin.

  It is OLL-31 mirrored to the back — same shape, different door; drill the B' ... B reach.

  B-door open

  R U B' prepares the layers and opens the back face.

  Insert and close

  U' R' U R inserts a corner, then B R' closes the back door and finishes the top.

  AUF {netAlign}

  Rotate U to the algorithm's starting angle.

  Rotate U to match the algorithm's starting angle.

  AUF adjust

  Rotate the U layer so the top pattern lines up with the algorithm's start angle.

• P-shape — Left wide-layer flip

  Orient all top stickers from the L-shape (two adjacent edges up) with two corners up and a full bar plus headlights on a side, using a single left wide-layer flip.

  Construct the OLL-43 state.

  From the P-shape with a bar plus headlights set for the left wide layer, trigger the left wide-flip (OLL-43).

  Two adjacent edges oriented (L-shape) with two corners up and a full bar plus headlights on a side. The bar (a same-color corner-edge-corner column) marks this over the no-bar P-shapes; the f' wide-layer opening on the left picks the left wide-flip.

  An L of U-color edge stickers with two U-color corner stickers tracing a P, plus a complete same-color bar and headlights on a side face.

  AUF so the f' wide-layer opening sits on the correct face.

  f' L' U' L U f opens two layers of the front face, runs a left-hand L' U' L U insertion inside, and closes. A single wide-layer flip — clean and compact.

  Keep the wide f and the narrow L distinct — f lifts two layers, L lifts one.

  Left wide-layer flip

  f' L' U' L U f opens two front layers, twists the corners with a left-hand insertion, and closes — finishing the top.

  AUF {netAlign}

  Rotate U to the algorithm's starting angle.

  Rotate U to match the algorithm's starting angle.

  AUF adjust

  Rotate the U layer so the top pattern lines up with the algorithm's start angle.

• P-shape — Right wide-layer flip

  Orient all top stickers from the L-shape (two adjacent edges up) with two corners up and a full bar plus headlights on a side, using a single right wide-layer flip.

  Construct the OLL-44 state.

  From the P-shape with a bar plus headlights set for the right wide layer, trigger the right wide-flip (OLL-44).

  Two adjacent edges oriented (L-shape) with two corners up and a full bar plus headlights on a side — the right-hand mirror of OLL-43. The f wide-layer opening on the right is the tell.

  An L of U-color edge stickers with two U-color corner stickers tracing a P, plus a complete same-color bar and headlights on a side face — the right-side mirror of OLL-43.

  AUF so the f wide-layer opening sits on the correct face.

  f R U R' U' f' opens two layers of the front face, runs a standard sexy-move (R U R' U') insertion inside, and closes. The simplest wide-layer flip in all of OLL.

  Learn this early — the f ... f' frame around a single sexy move is a building block for many wide-layer OLLs.

  Right wide-layer flip

  f R U R' U' f' opens two front layers, runs a standard sexy-move insertion, and closes — finishing the top.

  AUF {netAlign}

  Rotate U to the algorithm's starting angle.

  Rotate U to match the algorithm's starting angle.

  AUF adjust

  Rotate the U layer so the top pattern lines up with the algorithm's start angle.

• T-shape — Insertion with edge flip

  Orient all top stickers from the line shape (two opposite edges up forming a bar) with two corners up turning it into a T, a same-color block, and no headlights, inserting a corner then flipping the remaining edge.

  Construct the OLL-33 state.

  From the T-shape with a block but no headlights at the insertion angle, trigger the insertion-then-flip formula (OLL-33).

  Two opposite edges oriented (a bar across the top) with two corners up turning it into a T, a same-color block, and no headlights. The R U R' U' insertion opener followed by an R' F R F' edge flip is the tell.

  A bar of two opposite U-color edge stickers plus two U-color corner stickers tracing a T, with a same-color block on a side face but no headlights.

  AUF so the R U R' U' insertion aligns with the T's stem.

  R U R' U' is the standard sexy-move insertion, then R' F R F' flips the remaining edge. The opener mirrors the PLL T-perm trigger — your hands already know it; the edge flip at the end is the only new part.

  The opener is the T-perm trigger — ride the familiar rhythm and just add the flip.

  Standard insertion

  R U R' U' is the standard sexy move, inserting a corner and setting up the edge for the flip.

  Edge flip

  R' F R F' opens the right face, flips the remaining edge, and closes — finishing the top.

  AUF {netAlign}

  Rotate U to the algorithm's starting angle.

  Rotate U to match the algorithm's starting angle.

  AUF adjust

  Rotate the U layer so the top pattern lines up with the algorithm's start angle.

• T-shape — Fundamental edge flip

  Orient all top stickers from the line shape (two opposite edges up forming a bar) with two corners up turning it into a T, a same-color block, and headlights, using the single fundamental edge-flip formula.

  Construct the OLL-45 state.

  From the T-shape with a block plus headlights at the front-door angle, trigger the beginner edge-flip (OLL-45).

  Two opposite edges oriented (a bar across the top) with two corners up turning it into a T, a same-color block, and headlights — the minimal T solved by the most fundamental edge flip. Every cuber learns it first.

  A bar of two opposite U-color edge stickers plus two U-color corner stickers tracing a T, with a same-color block and headlights on a side face.

  AUF so the F R U R' U' F' flip operates on the correct edges.

  F R U R' U' F' is the fundamental edge-flip formula — open F, run a sexy-move insertion, close F. The building block for many other OLLs; learn it early and the rest get easier.

  Open F, sexy move, close F' — the three-beat rhythm every edge flip shares.

  Fundamental edge flip

  F opens the front door, R U R' U' inserts a corner, and F' closes — flipping the edge and finishing the top.

  AUF {netAlign}

  Rotate U to the algorithm's starting angle.

  Rotate U to match the algorithm's starting angle.

  AUF adjust

  Rotate the U layer so the top pattern lines up with the algorithm's start angle.

• C-shape — R2 pivot with edge flip

  Orient all top stickers from the line shape (two opposite edges up) with two corners up curling it into a C, no headlights and no block, pivoting on an R2 before the edge flip.

  Construct the OLL-34 state.

  From the C-shape with no headlights at the R2-pivot angle, trigger the pivot-then-flip formula (OLL-34).

  Two opposite edges oriented (a bar) with two corners up curling it into a C, no headlights and no block. The R2 inside the R U R2 U' R' opener is the pivot that feeds the flip.

  A bar of two opposite U-color edge stickers plus two U-color corner stickers tracing a C, with no same-color block and no headlights on the sides.

  AUF so the R U R2 opener starts from the correct angle for the C.

  R U R2 U' R' is the R2-pivot setup, then F R U R U' F' is the edge-flip finish. The R2 midway through the first half redirects the whole sequence — feel it as the pivot point.

  The R2 is the pivot; let the edge-flip finish flow from it.

  R2 pivot

  R U R2 U' R' pivots on the R2 to set the corners up for the flip.

  Edge-flip close

  F R U R U' F' opens the front, flips the edge, and closes — finishing the top.

  AUF {netAlign}

  Rotate U to the algorithm's starting angle.

  Rotate U to match the algorithm's starting angle.

  AUF adjust

  Rotate the U layer so the top pattern lines up with the algorithm's start angle.

• C-shape — Short triple-R flip

  Orient all top stickers from the line shape (two opposite edges up) with two corners up curling it into a C, a full bar plus headlights, with a short triple-R opener and an edge-flip close.

  Construct the OLL-46 state.

  From the C-shape with a bar plus headlights at the triple-R angle, trigger the short flip formula (OLL-46).

  Two opposite edges oriented (a bar) with two corners up curling it into a C, plus a complete same-color bar with headlights. The triple-R opener R' U' R' is the signature tell — short and fast.

  A bar of two opposite U-color edge stickers plus two U-color corner stickers tracing a C, with a complete same-color bar and headlights on a side face.

  AUF so the R' U' R' triple-R opener aligns with the C.

  R' U' R' opens with the triple-R rhythm, then F R F' flips the edge and U R closes. Short and fast — one of the quicker OLL cases.

  The triple-R rhythm (R' U' R') is the signature opener — drill it for speed.

  Triple-R open

  R' U' R' opens with three right-layer moves, setting the corner for the flip.

  Edge-flip close

  F R F' flips the edge, then U R adjusts and closes — finishing the top.

  AUF {netAlign}

  Rotate U to the algorithm's starting angle.

  Rotate U to match the algorithm's starting angle.

  AUF adjust

  Rotate the U layer so the top pattern lines up with the algorithm's start angle.

• W — Left-hand continuous

  Orient all top stickers from the L-shape (two adjacent edges up) with two corners up tracing a W, a same-color block, and no headlights, using continuous left-hand work and an edge-flip finish.

  Construct the OLL-36 state.

  From the W-shape with a block but no headlights at the left-hand angle, trigger the left continuous formula (OLL-36).

  Two adjacent edges oriented (an L) with two corners up tracing a W, a same-color block, and no headlights. The continuous left-hand L' U' L U' ... opener is the tell — left-hand dominant.

  An L of U-color edge stickers plus two U-color corner stickers tracing a W, with a same-color block on a side face but no headlights.

  AUF so the L' U' L opener aligns with the W's left side.

  L' U' L U' L' U L U is continuous left-hand corner work (note the U/U' rhythm), then L F' L' F flips the remaining edges. Left-hand heavy — comfortable for lefties; righties should drill it slowly at first.

  Left-hand dominant — count the U/U' beats so the rhythm stays even.

  Left-hand continuous

  L' U' L U' L' U L U is continuous left-hand work, twisting the corners with a steady U/U' rhythm.

  Edge-flip close

  L F' L' F opens the left face, flips the remaining edges, and closes — finishing the top.

  AUF {netAlign}

  Rotate U to the algorithm's starting angle.

  Rotate U to match the algorithm's starting angle.

  AUF adjust

  Rotate the U layer so the top pattern lines up with the algorithm's start angle.

• W — Modified insertion with edge flip

  Orient all top stickers from the L-shape (two adjacent edges up) with two corners up tracing a W, a same-color block, and no headlights, using a modified right-hand insertion and a standard edge-flip finish.

  Construct the OLL-38 state.

  From the W-shape with a block but no headlights at the right-hand angle, trigger the modified-insertion formula (OLL-38).

  Two adjacent edges oriented (an L) with two corners up tracing a W, a same-color block, and no headlights — the right-hand mirror of OLL-36. The modified R U R' U R U' R' U' opener (the second U, not U', breaks the standard sexy-move) is the tell.

  An L of U-color edge stickers plus two U-color corner stickers tracing a W, with a same-color block on a side face but no headlights — the mirror of OLL-36.

  AUF so the R U R' opener aligns with the W's right side.

  R U R' U R U' R' U' is a modified insertion (the second U, not U', breaks the standard sexy-move rhythm), then R' F R F' is the standard edge flip. Right-hand dominant — the mirror of OLL-36.

  The opener is sexy-move-like but the second beat is U, not U' — feel the modified rhythm before speeding up.

  Modified insertion

  R U R' U R U' R' U' twists the corners with a modified U/U' rhythm (note the second U, not U').

  Edge-flip close

  R' F R F' opens the right face, flips the remaining edge, and closes — finishing the top.

  AUF {netAlign}

  Rotate U to the algorithm's starting angle.

  Rotate U to match the algorithm's starting angle.

  AUF adjust

  Rotate the U layer so the top pattern lines up with the algorithm's start angle.

• Big Lightning — Left F-wrap with left finish

  Orient all top stickers from the line shape (two opposite edges up) with two diagonal corners up tracing a big lightning bolt, a same-color block, and no headlights, using a left-hand F-wrap and a left-hand finish.

  Construct the OLL-39 state.

  From the big-lightning line with a block but no headlights at the left-hand angle, trigger the left F-wrap formula (OLL-39).

  Two opposite edges oriented (a horizontal line) with two diagonal corners up tracing a big lightning bolt, a same-color block, and no headlights. The L F' L' ... F wrap opener is the tell — left-hand dominant.

  A line of U-color edge stickers across the top plus two U-color corner stickers on a diagonal tracing a big lightning bolt, with a same-color block on a side face but no headlights.

  AUF so the L F' L' opener aligns with the bolt's left side.

  L F' L' U' L U F is a left-hand F-wrap (open the left face, work inside, close with F), then U' L' finishes. The F and F' bookend the wrap — keep them precise and don't overshoot; the final U' L' is a quick left-hand close.

  The F and F' frame the wrap — feel the open-work-close rhythm; the U' L' finish is quick.

  Left F-wrap

  L F' L' U' L U F opens the left face, twists the corners inside the wrap, and closes with F.

  Left-hand close

  U' L' realigns and closes on the left, finishing the top.

  AUF {netAlign}

  Rotate U to the algorithm's starting angle.

  Rotate U to match the algorithm's starting angle.

  AUF adjust

  Rotate the U layer so the top pattern lines up with the algorithm's start angle.

• Big Lightning — Right F-wrap mirror

  Orient all top stickers from the line shape (two opposite edges up) with two diagonal corners up tracing a big lightning bolt, a same-color block, and no headlights, using the right-hand mirror of the F-wrap and a right-hand finish.

  Construct the OLL-40 state.

  From the big-lightning line with a block but no headlights at the right-hand angle, trigger the right F-wrap mirror (OLL-40).

  Two opposite edges oriented (a horizontal line) with two diagonal corners up tracing a big lightning bolt, a same-color block, and no headlights — the right-hand mirror of OLL-39. The R' F R ... F' mirror wrap is the tell.

  A line of U-color edge stickers across the top plus two U-color corner stickers on the opposite diagonal tracing a big lightning bolt, with a same-color block on a side face but no headlights — the mirror of OLL-39.

  AUF so the R' F R opener aligns with the bolt's right side.

  R' F R U R' U' F' is the right-hand F-wrap mirror (every L becomes R, every R becomes L of OLL-39), then U R finishes. Right-hand dominant — comfortable for right-handed solvers.

  It is the exact mirror of OLL-39 — feel the L↔R symmetry rather than memorizing it fresh.

  Right F-wrap mirror

  R' F R U R' U' F' opens the right face, twists the corners inside the mirror wrap, and closes with F'.

  Right-hand close

  U R realigns and closes on the right, finishing the top.

  AUF {netAlign}

  Rotate U to the algorithm's starting angle.

  Rotate U to match the algorithm's starting angle.

  AUF adjust

  Rotate the U layer so the top pattern lines up with the algorithm's start angle.

• L-shape — Left-hand F-wrap

  Orient all top stickers from the L-shape (two adjacent edges up, all four corners misoriented) with a left-hand F-door wrap.

  Construct the OLL-47 state.

  From the L-shape with no bar but a headlights-plus-block side, trigger the left-hand F-wrap (OLL-47).

  Two adjacent edges oriented (L-shape) with zero corners up, a same-color block and headlights on a side, but no bar. No bar separates this from OLL-49/50/53/54; the block sitting on the left picks the left-hand wrap over OLL-48's mirror.

  An L of U-color edge stickers in one corner of the top face, no U-color corner stickers, and a same-color block plus headlights on a side face.

  AUF so the L's corner sits for the F' opening; the wrap reads left-handed from there.

  F' L' U' L U L' U' L U F opens the F-door left-handed, runs two L' U' L U left-hand insertions to twist the corners, then closes with F. The repeated L' U' L U is the memory hook.

  Split it as F' open → two L' U' L U insertions → F close; the doubled insertion is the whole case.

  F-door wrap

  F' L' U' L U L' U' L U F opens the front face, twists all four corners with two left-hand insertions, and closes — finishing the top.

  AUF {netAlign}

  Rotate U to the algorithm's starting angle.

  Rotate U to match the algorithm's starting angle.

  AUF adjust

  Rotate the U layer so the top pattern lines up with the algorithm's start angle.

• L-shape — Right-hand F-wrap

  Orient all top stickers from the L-shape (two adjacent edges up, all four corners misoriented) with a right-hand F-door wrap.

  Construct the OLL-48 state.

  From the L-shape with no bar but a headlights-plus-block side, trigger the right-hand F-wrap (OLL-48).

  Two adjacent edges oriented (L-shape) with zero corners up, a same-color block and headlights on a side, but no bar — the mirror of OLL-47. The block sits on the opposite side, which is why the right-hand (R moves) wrap fires here instead.

  An L of U-color edge stickers with no U-color corner stickers, and a same-color block plus headlights on the side face opposite OLL-47's.

  AUF so the L's corner sits for the F opening; the wrap reads right-handed from there.

  F R U R' U' R U R' U' F' opens the F-door right-handed, runs two R U R' U' sexy-move insertions to twist the corners, then closes with F'. The doubled sexy move inside the F-frame is the signature.

  It is an F-frame around two sexy moves — drill the F ... F' frame so both insertions sit cleanly inside.

  F-door wrap

  F R U R' U' R U R' U' F' opens the front face, twists all four corners with two right-hand sexy-move insertions, and closes — finishing the top.

  AUF {netAlign}

  Rotate U to the algorithm's starting angle.

  Rotate U to match the algorithm's starting angle.

  AUF adjust

  Rotate the U layer so the top pattern lines up with the algorithm's start angle.

• L-shape — Double-F into rotated edge-flip

  Orient all top stickers from the L-shape (two adjacent edges up, all four corners misoriented) with corner work, a y rotation, and an edge-flip finish.

  Construct the OLL-49 state.

  From the L-shape with a bar plus headlights, trigger the double-F-into-rotated-flip formula (OLL-49).

  Two adjacent edges oriented (L-shape) with zero corners up and a full bar plus headlights on a side. The bar (a same-color corner-edge-corner column) marks this over the no-bar cases (OLL-47/48); the R' F R' F' double-F opener is the tell.

  An L of U-color edge stickers with no U-color corner stickers, and a complete same-color bar plus headlights on a side face.

  AUF so the R' F R' F' opener reads from the current angle; be ready for the y rotation midway.

  R' F R' F' (a double-F corner maneuver) plus R2 U2 twists the corners and repositions the top, then y rotates the cube and R' F R F' flips the remaining edges to finish. The y changes your front face — the closer is a standard flip from the new angle.

  Read the closer R' F R F' as the same reusable edge-flip block used across OLL — only the y rotation makes this case feel new.

  Double-F corner work

  R' F R' F' R2 U2 twists the corners with a double-F maneuver and repositions the top with R2 U2.

  Rotated edge-flip

  y rotates the cube a quarter turn (note the new front face), then R' F R F' flips the remaining edges to finish the top.

  AUF {netAlign}

  Rotate U to the algorithm's starting angle.

  Rotate U to match the algorithm's starting angle.

  AUF adjust

  Rotate the U layer so the top pattern lines up with the algorithm's start angle.

• L-shape — Back-face corner work

  Orient all top stickers from the L-shape (two adjacent edges up, all four corners misoriented) with back-face corner work and a front-face finish.

  Construct the OLL-50 state.

  From the L-shape with a bar plus headlights, trigger the back-face-work formula (OLL-50).

  Two adjacent edges oriented (L-shape) with zero corners up and a full bar plus headlights on a side. Like OLL-49 it has a bar, but this one reaches the back face — the B' ... B pair is the distinguishing tell.

  An L of U-color edge stickers with no U-color corner stickers, and a complete same-color bar plus headlights on a side face.

  AUF so the R B' opener is reachable; the wrist rotation into the back face is the main challenge.

  R B' R B does the corner work on the back face, R2 U2 repositions the top, then F R' F' R finishes on the front. The B-to-F transition is the only awkward regrip.

  The B moves come as a B' ... B pair — keep your wrist light so the snap from back to front between the two halves stays clean.

  Back-face corner work

  R B' R B R2 U2 works the corners on the back face and repositions the top with R2 U2.

  Front-face finish

  F R' F' R opens the front face, inserts the corner, and closes to finish the top.

  AUF {netAlign}

  Rotate U to the algorithm's starting angle.

  Rotate U to match the algorithm's starting angle.

  AUF adjust

  Rotate the U layer so the top pattern lines up with the algorithm's start angle.

• L-shape — Left wide-layer wrap

  Orient all top stickers from the L-shape (two adjacent edges up, all four corners misoriented) with a long left-side wide-layer wrap.

  Construct the OLL-53 state.

  From the L-shape with a bar plus headlights, trigger the left wide-layer wrap (OLL-53).

  Two adjacent edges oriented (L-shape) with zero corners up and a full bar plus headlights on a side. The l' wide-layer opening on the left marks this case — it is the left-hand mirror of OLL-54.

  An L of U-color edge stickers with no U-color corner stickers, a same-color bar plus headlights on a side, and the geometry for a left-side wide-layer (l') opening.

  AUF for the l' opening; keep the wide l and narrow L layers distinct throughout.

  l' U' L U' L' U L U' L' is the corner work inside the wide-layer frame, then U2 l repositions and closes. The l' open and l close bookend the formula; the U2 is the handoff into the wide-layer close.

  The opener l' and closer l are the same wide-layer axis in opposite directions — drill the U2 handoff so the close feels like the natural echo of the open.

  Wide-layer corner work

  l' U' L U' L' U L U' L' opens the left wide layer, twists the corners with L-layer insertions, and holds them for the close.

  Wide-layer close

  U2 l repositions the top with U2 and closes the left wide layer (l) to finish the top.

  AUF {netAlign}

  Rotate U to the algorithm's starting angle.

  Rotate U to match the algorithm's starting angle.

  AUF adjust

  Rotate the U layer so the top pattern lines up with the algorithm's start angle.

• L-shape — Right wide-layer wrap

  Orient all top stickers from the L-shape (two adjacent edges up, all four corners misoriented) with a long right-side wide-layer wrap.

  Construct the OLL-54 state.

  From the L-shape with a bar plus headlights, trigger the right wide-layer wrap (OLL-54).

  Two adjacent edges oriented (L-shape) with zero corners up and a full bar plus headlights on a side — the right-hand mirror of OLL-53. The r wide-layer opening on the right is the tell.

  An L of U-color edge stickers with no U-color corner stickers, a same-color bar plus headlights on a side, and the geometry for a right-side wide-layer (r) opening.

  AUF for the r opening; keep the wide r and narrow R layers distinct throughout.

  r U R' U R U' R' U R is the corner work inside the wide-layer frame, then U2 r' repositions and closes. It is OLL-53 mirrored: every l becomes r, every L becomes R.

  If you know OLL-53, mirror it — every left move becomes its right-hand twin, and the r' close is the echo of the r open.

  Wide-layer corner work

  r U R' U R U' R' U R opens the right wide layer, twists the corners with R-layer insertions, and holds them for the close.

  Wide-layer close

  U2 r' repositions the top with U2 and closes the right wide layer (r') to finish the top.

  AUF {netAlign}

  Rotate U to the algorithm's starting angle.

  Rotate U to match the algorithm's starting angle.

  AUF adjust

  Rotate the U layer so the top pattern lines up with the algorithm's start angle.

• I-shape — Wide F-door with double insertion

  Orient all top stickers from the line shape (two opposite edges up in an I) with no corners up and a same-color block, firing a single wide-layer F-door that holds two insertions to finish the cross.

  Construct the OLL-51 state.

  From the I-shape line with a block at the double-insertion angle, trigger the wide double-flip (OLL-51).

  Two opposite edges oriented (a horizontal line across the middle) with no corners up and a same-color block. The single wide f ... f' frame holding two sexy moves is the tell — the simplest I-shape member.

  A horizontal line of U-color edge stickers across the top middle with no U-color corner stickers up.

  AUF so the f wide-layer opener aligns with the line's orientation.

  f R U R' U' R U R' U' f' opens two layers of the front face, runs two standard sexy moves (R U R' U') inside, and closes. The f and f' bookend the whole sequence — don't forget the close.

  It is one wide F-door holding two sexy moves — count the insertions so the f' close lands on time.

  Wide F-door double flip

  f opens two front layers, two R U R' U' insertions flip the edges, and f' closes — finishing the cross and the top.

  AUF {netAlign}

  Rotate U to the algorithm's starting angle.

  Rotate U to match the algorithm's starting angle.

  AUF adjust

  Rotate the U layer so the top pattern lines up with the algorithm's start angle.

• I-shape — d' double-layer reposition

  Orient all top stickers from the line shape (two opposite edges up in an I) with no corners up and a full bar plus headlights, using a d' double-layer repositioning in the middle.

  Construct the OLL-52 state.

  From the I-shape line with a bar at the d'-reposition angle, trigger the d-move formula (OLL-52).

  Two opposite edges oriented (a horizontal line across the middle) with no corners up and a complete same-color bar plus headlights. The d' move (D plus middle layer together) in the opener is the tell — uncommon and worth drilling slowly.

  A horizontal line of U-color edge stickers across the top middle with no U-color corner stickers up, plus a complete same-color bar and headlights on a side.

  AUF so the R U R' U R d' opener starts from the correct angle.

  R U R' U R d' repositions with a d' (the D layer and middle slice turn together, the bottom-up twin of a U'), then R U' R' F' closes. The d' is the only awkward finger-trick — practice it before speed.

  The d' is D + middle layer together — think of it as a bottom-up U' and let the rest flow.

  Reposition with d'

  R U R' U R twists a corner, then d' (D layer and middle slice together) repositions the bottom layers.

  Close

  R U' R' adjusts the corner, then F' closes and finishes the top.

  AUF {netAlign}

  Rotate U to the algorithm's starting angle.

  Rotate U to match the algorithm's starting angle.

  AUF adjust

  Rotate the U layer so the top pattern lines up with the algorithm's start angle.

• I-shape — R2 cascade then edge flip

  Orient all top stickers from the line shape (two opposite edges up in an I) with no corners up and a full bar plus headlights, running an R2 cascade before the edge flip.

  Construct the OLL-55 state.

  From the I-shape line with a bar at the R2-cascade angle, trigger the cascade-then-flip formula (OLL-55).

  Two opposite edges oriented (a horizontal line across the middle) with no corners up and a complete same-color bar plus headlights. The R2 cascade midway through the first half is the pivot that feeds the flip.

  A horizontal line of U-color edge stickers across the top middle with no U-color corner stickers up, plus a complete same-color bar and headlights on a side.

  AUF for the R U2 R2 opener.

  R U2 R2 U' R U' R' is corner work pivoting on the R2, then U2 F R F' flips the remaining edge. The R2 inside the first half redirects the whole sequence — feel it as the pivot point.

  The R2 is the pivot; let the U2 before the flip reset your rhythm.

  R2 cascade

  R U2 R2 U' R U' R' pivots on the R2 to twist the corners into position.

  U2 and flip

  U2 realigns the top, then F R F' flips the remaining edge to finish the cross and the top.

  AUF {netAlign}

  Rotate U to the algorithm's starting angle.

  Rotate U to match the algorithm's starting angle.

  AUF adjust

  Rotate the U layer so the top pattern lines up with the algorithm's start angle.

• I-shape — Flip first, then wide close

  Orient all top stickers from the line shape (two opposite edges up in an I) with no corners up, opening with an extended edge flip and closing with right wide-layer corner work.

  Construct the OLL-56 state.

  From the I-shape line at the flip-first angle, trigger the flip-then-wide formula (OLL-56).

  Two opposite edges oriented (a horizontal line across the middle) with no corners up. The reversed order — flip the edges first, then finish the corners with a wide r ... r' — is the tell.

  A horizontal line of U-color edge stickers across the top middle with no U-color corner stickers up.

  AUF so the F R U R' U' R F' flip operates on the correct edges.

  F R U R' U' R F' is an extended edge flip (the extra R before F' sets it apart from the beginner flip), then r U R' U' r' is a right wide-layer finish for the corners. Flip-first, wide-close — the reverse of the wide-then-flip pattern.

  Note the extra R in the flip — F R U R' U' R F', not the beginner F R U R' U' F'.

  Extended edge flip

  F R U R' U' R F' flips the edges (the extra R before F' extends the beginner flip).

  Wide-layer close

  r U R' U' r' opens and closes the right wide layer to finish the corners and the top.

  AUF {netAlign}

  Rotate U to the algorithm's starting angle.

  Rotate U to match the algorithm's starting angle.

  AUF adjust

  Rotate the U layer so the top pattern lines up with the algorithm's start angle.

• Arrow — Insertion with M-slice finish

  Orient all top stickers with all four corners already up and two opposite edges oriented in a line, plus a same-color bar and headlights, opening with a standard insertion and finishing with M-slice and wide-layer work.

  Construct the OLL-57 state.

  From the arrow-shape with all corners up and a bar at the insertion angle, trigger the insertion-then-M-slice formula (OLL-57).

  All four corners already oriented with two opposite edges up in a line, plus a same-color bar and headlights. The R U R' U' insertion opener followed by an M' ... r' wide-layer close is the tell.

  Four U-color corner stickers up with a line of two opposite U-color edge stickers, plus a same-color bar and headlights on the sides.

  AUF so the R U R' U' insertion aligns with the un-oriented edges.

  R U R' U' is a standard insertion, then M' U R U' r' finishes with M-slice and right wide-layer work. The final r' is a two-layer move — don't accidentally do a single-layer R'.

  The finish mixes M-slice and a wide r' — keep the r' as two layers, not a single R'.

  Standard insertion

  R U R' U' is a standard insertion that repositions a corner.

  M-slice + wide close

  M' U R U' r' slides the M slice and closes with a right wide-layer move to finish the top.

  AUF {netAlign}

  Rotate U to the algorithm's starting angle.

  Rotate U to match the algorithm's starting angle.

  AUF adjust

  Rotate the U layer so the top pattern lines up with the algorithm's start angle.

CFOP OLL Tutorial