# How the Orozco BLD method works

#### ottozing

##### Platinum Member
Have found little to no discussion on this method in any English speaking corners of the cubing community, but I've looked into this method a bit and I think it's quite a good intermediate method between beginner methods and full 3style. Frankly, I wish I had thought of this before pursuing BLD because the UBL/DF buffer combo doesn't generate amazing comms compared to say UFR/UF, which is what this method uses. However, really you can apply this method to any set of buffers quite easily, which is why I think it's such a great stepping stone to 3cycles as it allows you to use better buffers while having an intermediate method to fall back on.

The way the method works is very easy to relate to M2 edges, so I'll be using that as my initial example. With M2, you have 2 important pieces. Your buffer (DF) and your helper piece (UB). Now, take any solution you can think of to solve a single target such as FR, which is U R U' M2 U R' U', or even a harder case such as FU, which is F E R U R' E' R U' R' F' M2. For every single target solution, if you attach an M2 to the end of it, you get the cycle buffer>target>helper piece, and if you attach an M2 to the start of any target not in the M layer (Because they work differently), you get buffer>helper>target.

The main point I'm trying to get across is that with M2, you're basically cycling buffer>target>helper and buffer>helper>target over and over again which solves every piece. In old pochmann terms, that's the equivalent of solving the cycle UBL>UFR>ULF by doing Y perm, 2 L perms, and a U2 J perm U2 (Where L perm = R' U L' U2 R U' R' U2 R L U' and UBR is the "helper" piece).

Now here's where the Orozco method comes in. The basic idea is that using UFR/UF buffers, and UBR/BU helper pieces, you learn 21 commutators forwards and backwards for corners and 22 commutators forwards and backwards for edges. For every odd target you get in a solve, you UFR/UF>target>UBR/BU, and for every even target you cycle UFR/UF>UBR/BU>helper. The only thing left to mention is how you solve when your next target is the helper piece and it's not in its helper orientation. In the M2 method, when you have to shoot to BU you essentially do an algorithm that flipped the buffer and the helper and then do an M2 (Something like [U M']3 U M [U M']4). With the Orozco method it's the same without adding a move at the end.

D2 R2 B2 D F2 D F2 L2 U L' B' R2 U' R2 D' R B F' R'

R' U2 R' D' R U2 R' D R2 (UFR>BUL>URB)
R2 D' R2 D R2 U R2 D' R2 D R2 U' (UFR>URB>DFR)
R2 D R' U2 R D' R' U2 R' (UFR>FLU>URB)
U' R D2 R' U R D2 R' (UFR>URB>FLD)
R U2 R' U' R U' R' L' U2 L U L' U L (UFR>RBU>UBR)
R' D R U R' D' R U' (UFR>UBR>RDF)
R D R' U' R D' R' U (UFR>RDB>UBR)
U' R D' R' U R D R' (UFR>UBR>LBD)
Leaving last target until end

M U L U' M' U L' U' (UF>BL>BU)
U' R' U M U' R U M' (UF>BU>BR)
R U R' U' M' U R U' r' (UF>RU>BU)
U L' U' M U L U' M' (UF>BU>FL)
U R U' M' U R' U' M (UF>RF>BU)
M' U R' U' M U R U' (UF>BU>RB)
M U' R2 U M' U' R2 U (UF>DR>BU)
M' U' L2 U M U' L2 U (UF>BU>LD)
U R2 U' M' U R2 U' M (UF>RD>BU)
F E R U R' E' R U' R' F' (UF>BU>FD)
l U L' U' M' U L U' L' (UF>UL>BU)
Skip! (UF>BU>BU)

B2 r U R' U R U R' F' R U R' U' R' F R2 U' R' U2 R U' R' U2 M B2 (Bad parity)

That's pretty much all there is to it. With these ideas you could make similar methods depending on what buffer you want to learn. For example, if you're already comfortable with comms using UBL corner buffer, maybe you'd rather have a UB edge buffer to make parity solving a bit easier (adjacent buffers ftw). As of right now though, I'm pretty sure UF and UFR and the best buffers

D

#### Daniel Lin

##### Guest
This is a cool method but I don't think its very useful. If you're willing to learn 21/22 commutators you may as well do a setup move and solve two targets at a time. I think this method is a better transition from OP to 3style
http://speedcubing.ru/forum/index.php?topic=53.0 (sorry the page isn't in english. but basically your buffer is UBL and you set up one target to FDR and do a comm) I've used this method for corners on 3x3 and even on x centers and tcenters on bigcubes.

#### ottozing

##### Platinum Member
This is a cool method but I don't think its very useful. If you're willing to learn 21/22 commutators you may as well do a setup move and solve two targets at a time. I think this method is a better transition from OP to 3style
http://speedcubing.ru/forum/index.php?topic=53.0 (sorry the page isn't in english. but basically your buffer is UBL and you set up one target to FDR and do a comm) I've used this method for corners on 3x3 and even on x centers and tcenters on bigcubes.
Yeah, that method is pretty much how Noah suggests to go about learning 3style. While it's nice and all because it solves 2 pieces at once, you can build up a lot of bad habits for solving certain comms this way (Something Noah admits in his guides). With this method, even though it's one piece at a time, most of the comms are very easy to learn and also very easy to execute around 1sec, especially for corners. Plus, the fact that it gives you very nice buffers is a pretty big selling point if you're serious enough about blind.

The main reason I posted the thread was just to explain how it works though. You can use any buffer and any helper piece on the cube and use it the same way. My recommendation for anyone who's comfortable with 3style for one piece type but not the other would be to either learn other piece type using UF/UFR buffer, or to pick a different buffer that's adjacent to the buffer they're comfortable with.

#### cmhardw

I just saw this thread referenced in another thread. Daniel Beyer has used this method for wings and 3x3 corners since around 2006. He and I created the BH method together and he switched to that, but before BH he used this same buffer/helper-buffer method for those pieces.

I will ask him if he learned this from somewhere or if he discovered it on his own.

Glad the method works for you, Daniel also spoke very highly of it as a solid intermediate method for BLD that lets you learn a smaller number of cycles that can be trained to be very fast.

#### TDM

##### Super Moderator
Staff member
Looks like I forgot to post this back when I made it: alg list for UF/UFR
There are a couple of shortcuts involving Parity on the first tab too:

You usually shoot to BU/UBR the first time you have a new target. So sometimes (when your last target is BU or UBR), your solve would end with a flipping/twisting alg of two U layer pieces, followed by a LL algorithm for parity. Instead, you can learn different LL algorithms to solve these cases:
U R' U R U' x' U r' F r U2 r U' R' U M (x)
r U' r' U' r U r' U2 r' D' r U' r' D r U'
F perm
y R' U' R2 U R' F' R U R' U' R' F R2 U' R' U' R' U R
U2 R2 F' R U R' U' R' F R2 U' R' U2 R2 U R' U R
(if anyone has any better algs, please let me know!)

If your last target can be easily set up to FD (without affecting UFR/UBR), you can skip solving it, and instead set up to [M': parity]. For example, if your last target was LD:
Normal solution:
U' L2 U M' U' L2 U M // LD
R U2 R' U2 R' F R U R U2 R' U' R U R' F' // Parity
Shortcut solution:
D M' // setup
R U2 R' U2 R' F R U R U2 R' U' R U R' F' // Parity
M D' // undo setup

A similar thing can be done if your last corner target can easily be set up to RDF. In this case, you would do [R: parity]. For example if your last target was BDR, you can solve this with:
(D' R) R U2 R' U2 R' F R U R U2 R' U' R U R' F' (R' D)

NOTE: this can be combined with the previous shortcut

None of these other ones are about parity.

If one of the pieces in a pair is a 1-move set up to the helper, you can do that setup and solve the other piece normally. A couple of examples:

UF -> BL -> RF: BL is a one move (B') setup to the helper, BU. So we can do:
B' // setup
M' U R U' M U R' U' // RF
B // undo setup

UFR -> LUB -> DBL: DBL is a one move (B2) setup to the helper, UBR. So we can do:
B2 // setup
R D R' U' R D' R' U // "LUB" (notice our setup actually moved the position of the other target, so we had to do the alg for RDB instead)
B2 // undo setup

The second example was a bit more advanced, but uses the same idea.
Another, similar trick can be done to "skip" solving FD or UFL. To skip FD, start the pair with M'. Then solve the other piece as if it was the other part of the pair. So if the other piece was the second target, you would do the algorithm as if it were the first target. A similar thing can be done to skip UFL by starting with a U'.
Again, two examples:

UF -> RU -> FD:
M' // setup
r U R' U' M U R U' R' // RU (notice this is the algorithm for when RU is the second target in its pair)
M // undo setup
UFR -> UFL -> DFL:
U' // setup
x' R U R' D2 R U' R' D2 x // DFL (this is the alg for when DFL is the first target in a pair)
U // undo setup

To solve edge pairs involving DB (which is otherwise a difficult sticker), you can use M2-type solutions. There are two ways of doing this:
1. Do an x'. This gives you a normal M2 case. Notice one of your targets is UB so that can be solved with an M2. Your other target will need to be solved normally.
2. You can do front/back mirrors of normal algorithms, treating DB as your buffer and UF as your helper. This is what I do, as it doesn't involve rotating. For example:

UF -> FL -> DB:
M2 // solve BD->UF
U L' U' M2 U L U' // solve FL->BD

If you have both targets on the U or F faces, it can be best to use TuRBo. In fact, I usually solve edge targets involving DF by setting up to a TuRBo case. A couple of examples:

UF -> RU -> UB:
y M U' M' U2 M U' M' y'

UF -> BR -> DF:
R2 // setup
x y M U M' U2 M U M' y x' // TuRBo alg
R2 // undo setup

Here's an example solving using some of these tricks: acn
This is 120 moves; for comparison, ottozing's was 193.

Last edited:
D

#### Daniel Lin

##### Guest
If your last target can be easily set up to FD (without affecting UFR/UBR), you can skip solving it, and instead set up to [M': parity]. For example, if your last target was LD:
uh what do you mean by skip solving it? You're just solving it with an alg...

Spoiler: "Skipping" targets mid-solve
yeah this is pretty similar to advanced M2

UF -> RU -> UB:
y M U' M' U2 M U' M' y'
U is better than y

UF -> BR -> DF:
R2 // setup
x y M U M' U2 M U M' y x' // TuRBo alg
R2 // undo setup
tbh i don't think these tricks are worth since if you want to learn comms its prob easier learn the optimal stuff from the start

U R' U M' U2 M U R U'

#### TDM

##### Super Moderator
Staff member
uh what do you mean by skip solving it? You're just solving it with an alg...
Rather than doing an alg to solve it followed by a parity alg (total of 2 algs), you're doing a short setup to 1 alg.

Obviously none of the "skips" are really skips (bar choice of words, sorry) - they're more like shortcuts.

U is better than y
Well, as you can probably tell I'm bad at TuRBo

tbh i don't think these tricks are worth since if you want to learn comms its prob easier learn the optimal stuff from the start

U R' U M' U2 M U R U'
Very true! Which alg would you use if the target was RB, rather than BR?

#### TDM

##### Super Moderator
Staff member
UF -> RB -> DF : B U2M'U2M B', maybe not the best, what do you use Daniel ?
(I'm not Daniel, but) how about these?
[u R U: M' U2 M U2] // don't really like
[U2: [M2, u R u']] // bit long
[x D': [U2, M']] // near enough the same alg as yours, but with a rotation

#### TDM

##### Super Moderator
Staff member
Looks like I forgot to post this back when I made it: alg list for UF/UFR
There are a couple of shortcuts involving Parity on the first tab too:

You usually shoot to BU/UBR the first time you have a new target. So sometimes (when your last target is BU or UBR), your solve would end with a flipping/twisting alg of two U layer pieces, followed by a LL algorithm for parity. Instead, you can learn different LL algorithms to solve these cases:
U R' U R U' x' U r' F r U2 r U' R' U M (x)
r U' r' U' r U r' U2 r' D' r U' r' D r U'
F perm
y R' U' R2 U R' F' R U R' U' R' F R2 U' R' U' R' U R
U2 R2 F' R U R' U' R' F R2 U' R' U2 R2 U R' U R
(if anyone has any better algs, please let me know!)

If your last target can be easily set up to FD (without affecting UFR/UBR), you can skip solving it, and instead set up to [M': parity]. For example, if your last target was LD:
Normal solution:
U' L2 U M' U' L2 U M // LD
R U2 R' U2 R' F R U R U2 R' U' R U R' F' // Parity
Shortcut solution:
D M' // setup
R U2 R' U2 R' F R U R U2 R' U' R U R' F' // Parity
M D' // undo setup

A similar thing can be done if your last corner target can easily be set up to RDF. In this case, you would do [R: parity]. For example if your last target was BDR, you can solve this with:
(D' R) R U2 R' U2 R' F R U R U2 R' U' R U R' F' (R' D)

NOTE: this can be combined with the previous shortcut

None of these other ones are about parity.

If one of the pieces in a pair is a 1-move set up to the helper, you can do that setup and solve the other piece normally. A couple of examples:

UF -> BL -> RF: BL is a one move (B') setup to the helper, BU. So we can do:
B' // setup
M' U R U' M U R' U' // RF
B // undo setup

UFR -> LUB -> DBL: DBL is a one move (B2) setup to the helper, UBR. So we can do:
B2 // setup
R D R' U' R D' R' U // "LUB" (notice our setup actually moved the position of the other target, so we had to do the alg for RDB instead)
B2 // undo setup

The second example was a bit more advanced, but uses the same idea.
Another, similar trick can be done to "skip" solving FD or UFL. To skip FD, start the pair with M'. Then solve the other piece as if it was the other part of the pair. So if the other piece was the second target, you would do the algorithm as if it were the first target. A similar thing can be done to skip UFL by starting with a U'.
Again, two examples:

UF -> RU -> FD:
M' // setup
r U R' U' M U R U' R' // RU (notice this is the algorithm for when RU is the second target in its pair)
M // undo setup
UFR -> UFL -> DFL:
U' // setup
x' R U R' D2 R U' R' D2 x // DFL (this is the alg for when DFL is the first target in a pair)
U // undo setup

To solve edge pairs involving DB (which is otherwise a difficult sticker), you can use M2-type solutions. There are two ways of doing this:
1. Do an x'. This gives you a normal M2 case. Notice one of your targets is UB so that can be solved with an M2. Your other target will need to be solved normally.
2. You can do front/back mirrors of normal algorithms, treating DB as your buffer and UF as your helper. This is what I do, as it doesn't involve rotating. For example:

UF -> FL -> DB:
M2 // solve BD->UF
U L' U' M2 U L U' // solve FL->BD

If you have both targets on the U or F faces, it can be best to use TuRBo. In fact, I usually solve edge targets involving DF by setting up to a TuRBo case. A couple of examples:

UF -> RU -> UB:
y M U' M' U2 M U' M' y'

UF -> BR -> DF:
R2 // setup
x y M U M' U2 M U M' y x' // TuRBo alg
R2 // undo setup

Here's an example solving using some of these tricks: acn
This is 120 moves; for comparison, ottozing's was 193.
I wrote some of these up in more depth, plus I included a couple of other things. I'm still looking for feedback on this, so if you feel anything doesn't belong/is wrong/have something to add, please comment.

#### Nam Dank the Tank

##### Member
jus learned corners for this method and switched to it... its very good intermediate method and fast comms as well

#### theawesomecuber

##### Member
I've been using orozco/orozco for 3BLD for a little while now, and I just wanted to ask what the best "helper" target would be for a UFR x-centers buffer. Same question for UF t-centers buffer. Thanks!

edit: After a quick look, I have concluded that using URB as a helper target for x-centers would probably be easiest. Not sure what would be best for t-centers, but not knowing right now is fine, I don't plan on attempting 5BLD for a while.

Last edited:

#### Dylan Swarts

##### Member
I am struggling to find someplace to help me because using Orozco I need to memo extra things like sometimes I need to use an inverse because I ended up getting the helper as my target and then need to have an even target after an even target or an odd target after an odd target which is confusing to memorise and also memorising when I need to twist the helper piece. I'm hoping it's just me doing this wrong and someone can help me do this correctly please because I need to be able to do this so I can move to 3 style

#### Arc

##### Member
I am struggling to find someplace to help me because using Orozco I need to memo extra things like sometimes I need to use an inverse because I ended up getting the helper as my target and then need to have an even target after an even target or an odd target after an odd target which is confusing to memorise and also memorising when I need to twist the helper piece. I'm hoping it's just me doing this wrong and someone can help me do this correctly please because I need to be able to do this so I can move to 3 style
There's no need to memorize anything more with Orozco than with OP/OP. It sounds like you are not memorizing letters in pairs. Did you skip M2? Basically if your memo is ABDEFG you should be remembering that as AB DE FG. There's no need to memorize whether a target is even or odd. As you're executing you know the first of every pair is odd and the second is even.

As far as the helper targets go, you're over thinking it. There's no need to memorize anything but the letter, just like OP. And if you get (assuming speffz) N you do do the alg for N. And if you get Q you do the alg for Q. It may be slightly confusing that the alg for Q is the inverse of N (and vice versa), so if you get Q as an even target, the inverse that you'll do is indeed identical to the N alg. But don't even think about that. There's nothing special about the helper targets at all.

My tutorial: