What is Orozco?

Orozco is an intermediate method for 3BLD. For edges, it’s a similar level to M2 or TuRBo
edges in terms of difficulty/speed. For corners, it’s more advanced than, and faster than, OP.
Orozco can (like most methods) be applied to several buffers. In fact, you can use any buffer
you like, but it is highly recommended to use UF/UFR, as these are generally considered the
best buffers for 3BLD when using 3-style. For the purpose of this tutorial (and almost every
Orozco tutorial you’ll see), we will use the following buffer and helper positions:
Edge buffer: UF
Edge helper: BU
Corner buffer: UFR
Corner helper: UBR
(If you don’t know what a helper piece is: it’s the location you “shoot” too, e.g. the RDF sticker in
OP corners, or the UB sticker in M2 edges)

Orozco can be learned intuitively (the purpose of this tutorial), or algorithmically. It’s highly
recommend to take the intuitive approach, as if you don’t know anything about commutators,
this guide will teach you the foundations of what you need to know for 3-style. If you do already
know about commutators, this will be a simple method to learn.

Advantages and disadvantages compared to other

beginner-intermediate methods
Pros:
- Better buffers when switching to 3-style
- Simple, fast parity
- Lots of advanced tricks
- Easy transition into 3-style
- Considerably faster than OP corners, but not much harder
- Easily applicable to bigcubes
Cons:
- Harder to learn than M2/OP
- Fewer resources (that’s why this exists!)
- Not any faster than M2 edges (though not any slower, either)

A brief introduction to commutators

You can skip this section if you already know about commutators and conjugates. Although
you’d probably be better off just learning 3-style, because 3-style is conceptually simpler and
much faster.
Orozco uses commutators to solve pieces. Although you do not need to understand
commutators to use Orozco, it is strongly recommended as Orozco is best used as a step
towards 3-style. A comprehensive guide to them can be found here. The whole video contains
useful information that will help your understanding of commutators, but only parts of it are
directly relevant to Orozco. Since Orozco is a stepping-stone method to 3-style it’s probably best
if you watch the whole thing, but if you just want the relevant parts, they are 0:00-5:45 and
14:11-23:10. Other potentially useful information can be found in the segments 5:45-9:20 and
26:49-31:20.

There are some definitions, facts and notation you will need to know for this tutorial.

● Commutators: an algorithm of the form X Y X’ Y’, where X and Y are any sequences of
moves, and ’ indicates an inverse of the sequence.
● Conjugates: a “setup move”. If an algorithm is of the form Z A Z’ (where Z and A are any
sequences of moves), then Z is called a conjugate.
● Notation
○ X Y X’ Y’ is written as [X, Y].
○ Z A Z’ is written as [Z: A].
○ Commutators are often nested inside conjugates, e.g. Z X Y X’ Y’ Z’ is written as
[Z: [X, Y]].
■ All of this notation is supported by alg.cubing.net.
○ Sometimes, [Z: [X, Y]] is written as [Z: X, Y].
■ This notation is not supported by alg.cubing.net.
○ The notation piece1 -> piece 2 -> piece 3 means an algorithm which moves
piece1 into the position of piece2, piece2 into the position of piece3, and piece3
into the position of piece1.
■ For example, the algorithm M2 U M U2 M’ U M2 moves UF -> UR -> UL.
● Inverses
○ The inverse of [X, Y] is [Y, X].
○ The inverse of [Z: A] is [Z: A’].
○ Therefore, the inverse of [Z: [X, Y]] is [Z: [Y, X]].
○ The inverse of the cycle “piece1 -> piece2 -> piece3” is “piece1 -> piece3 ->
piece2”

Method overview
Orozco uses a 3-cycle commutator to solve each target. You will need to memorise pieces in
pairs. If a target is odd (i.e. the first target in a pair), you will do a commutator for buffer -> target
-> helper. If the target is even (i.e. the second target in the pair), you will need to do a
commutator which does buffer -> helper -> target. Note that this is the inverse of the given
algorithm on the algorithm list (see below). Don’t worry, you won’t have to figure out these
commutators while blindfolded, or memorise a long list - there are explanations of the algorithms
below, which will greatly reduce the amount you have to memorise.
TLDR: If the target is odd, use an algorithm from the set below. If the target is even, use the
inverse.

In case you’re interested in why we need to use inverses for even targets: The first commutator
moves the piece in the buffer to the first target, solving the first target, but the second piece is
moved into the helper position. The second comm in a pair therefore has to move the piece in
the helper position to the second target, while also bringing the piece from the second target
into the buffer. This cycle ends up being buffer -> helper -> target, which is the inverse.

Edges
We will split the edges into four types of targets:
● L/R faces
● L/R layers, not on L/R face
● DF and DB pieces
● UB piece
A cheat sheet with all the algorithms on is available here.

L/R faces

LU [L’ U’ L U, M’] RU [R U R’ U’, M’]

LF [U’ L’ U, M’] RF [U R U’, M’]

LD [U’ L2 U, M’] RD [U R2 U’, M’]

LB [U’ L U, M’] RB [U R’ U’, M’]

These are all of the form [set up target to helper, M’].

These setup moves will be similar to those you may have used if you know M2 edges, except
these setups are for the “wrong” sticker on each edge, as we are using BU as our helper instead
of UB (which is what M2 uses).

L/R layer, not on L/R face

UL [M, L U L’ U’] UR [M, R’ U’ R U]

FL [M, U L’ U’] FR [M, U’ R U]

DL [M, U L2 U’] DR [M, U’ R2 U]

BL [M, U L U’] BR [M, U’ R’ U]

These are all of the form [M, set up target to buffer].

DF and DB pieces

DF [D: [M, U’ R2 U]] DB [D’: M, U’ R2 U]]

FD [D: [U R2 U’, M’]] BD [D’: [U R2 U’, M’]]

These are all setups to algorithms in the above sections.

UB piece

UB M’ U M’ U M’ U M’ U2 M’ U M’ U M’ U M’ BU Skip!

The UB alg is just a two edge flip, and does not need to be inverted if the target is even.
There is no alg for BU because this is the helper piece. Just move on to the next target.

Corners
We will split the corner targets into four groups:
● UL pieces
● D layer, not on D face
● D face
● UBR piece
A cheat sheet with all the algorithms on is available here.

UL pieces

UFL U’ l’ U R’ D2 R U’ R’ D2 R2 x’ U UBL l’ U R’ D2 R U’ R’ D2 R2 x’

LUF R’ U’ R’ D’ R U R’ D R2 LUB R2 D R’ U R D’ R’ U’ R’

FUL R2 D R’ U2 R D’ R’ U2 R’ BUL R’ U2 R’ D’ R U2 R’ D R2

The first two are A perms; they’re the same A perm but one has an AUF before.
The other four are COLLs.
All of these are commutators; for example, the algs in the right hand column can be written as [x
R2: R U R’, D2], [R2: D, R’ U R] and [R2: R U2 R’, D’]. However I wrote these algs out in full in
the table to make it easier to notice many of these are common algs in sighted speedsolving,
and you may already know most of them.

D layer, not on D face

LDF [U, R’ D R] LDB [R D’ R’, U’]

 FDR [U, D’ R’ D R]] FDL [R D2 R’, U’]

RDB [R D R’, U’] RDF [U, R’ D’ R]

BDL [U, R’ D2 R] BDR [D R D’ R’, U’]

The algs all take one of two forms: either [U, setup target to buffer], or [setup target to
helper, U’].
Either form of algorithm can be used to solve any case, so don’t worry if you forget which type of
alg is used for which target - you can use either.

D face

DFL [x’: [R U R’, D2]] DFR [D’ x’: [R U R’, D2]]

DBL [x: [D2, R’ U’ R]] DBR [D x: [D2, R’ U’ R]]

The algs in the left column are 8 move comms.

The algs in the right column are conjugating to an alg in the left column.

UBR piece

RUB [U, R’ D R D’ R’ D R] BUR [R’ D R D’ R’ D R, U]

UBR Skip!

The first two are corner twists. You can use whatever your preferred algorithms are to twist
two corners. Despite these not being cycles, they are treated the exact same way as any other
case i.e. you use the inverse for even-numbered targets.
There is no alg for UBR because this is the helper piece. Just move on to the next target.

Parity
There are two approaches to parity: the basic approach (parity algorithms) and a more
advanced version (memo swapping).

Parity algorithms
This approach involves doing an alg at the end of the solve. Note that this is slightly different
from OP corners, in which you need to do the parity algorithm in the middle of the solve,
between edges and corners.
If using Orozco for both corners and edges, simply execute all targets as you memorised them
and you will be left with two edges and two corners swapped. (These will be your buffers and
helper pieces). Then do R U2 R' U2 R' F R U R U2 R' U' R U R' F'.

If you are mixing methods, e.g. M2 edges with Orozco corners, then you will need to do a
different algorithm. With M2 edges the best parity algorithms I know of are U2 M' U2 M' U M2
U2 M2 U R U R' U' R' F R2 U' R' U' R U R' F' and M2 U2 M' U2 r' U' F' R U R' U' R' F R2 U' R'
U' R U R' U R, though neither are particularly good.

Memo swapping
Memo swapping is a clever trick which lets you choose what your parity alg is. This method is
strongly recommended for people using M2 edges, because you can force a much faster parity
alg than the normal one.

You memo corners first. If there is parity then you choose two edges and “solve” them into the
wrong positions, i.e. you swap those two edges. When using Orozco corners these two edges
are usually chosen to be UF and UR. By solving the edges in this way, after executing all targets
you will be left with UFR-UBR swapped and UF-UR swapped which can be solved with a Jb
perm (R U R’ F’ R U R’ U’ R’ F R2 U’ R’ U’ ). You could also swap UL and UR to force a T perm
if you prefer.

An example solve using a memo swap can be found here.

Example solves
Example solve 1: Parity, but no cycle breaks or flipped edges/twisted corners. A very
straightforward solve.
Example solve 2: No parity, but there are cycle breaks in both edges and corners. Finishes with
twisted corners.

Final remarks
● Many of the algorithms given in this tutorial are not speed-optimal. A list with faster
algorithms can be found here.
● There are lots of tricks to make solves much faster and more efficient, similar to how
Advanced M2 is a collection of tricks to improve M2. A list of some of them can be found
here.
● Orozco can easily be applied to 4BLD/5BLD wings. No modifications need to be made
except for the UB and FU targets, both of which can be solved with simple [slice, flip
edge] commutators.
○ UBl (odd target; invert if even): [x’: [F R’ F’ U’ R2 U, r]]
○ FUl (odd target; invert if even): [r’, F R’ F’ U’ R2 U]
 ■ You can also solve these cases with [Lw’ D’: [U R2 U’, r]] and [Lw D: [r’, U’
R2 U]] respectively. These are just setting up to other cases. These are a
bit slower, but easier to remember.
○ Wing parity (UFr-BUr swap): l' U2 l' U2 F2 l' F2 r U2 r' U2 l2
○ Corner parity is best done with a memo swap.