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 recommended 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.
Pros:
Cons:
You can skip this section if you already know about commutators and conjugates. If you're very comfortable with them then you may be better off just learning 3-style though, 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.
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.
We will split the edges into four types of targets:
A cheat sheet with all the algorithms on is available here.
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).
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 | [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 | 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.
We will split the corner targets into four groups:
A cheat sheet with all the algorithms on is available here.
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.
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.
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.
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.
There are two approaches to parity: the basic approach (parity algorithms) and a more advanced version (memo swapping).
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: D R2' D' r2 U R D R' D' R U' R' U R' U'.
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 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.