I'm almost certain this method has been brought up before, so this is
not new. However I have been dedicating myself to learning an
existing BLD system with a new take on it.

I'm now solving the cube entirely with commutators, and I solve
position and orientation at the same time. So I both position and
orient pieces 2 at a time if possible.

Each sticker of each piece is given a letter and I memorize using my
usual images from big cube BLD. I have the problem of what I call
"unbalanced" cycles which I handle by orienting those pieces before I
start solving. For the 5x5x5 I use commutators for this, for the
3x3x3 I just use regular orientation algs.

Here is an example solve, with the memorization as well.

Scramble the cube starting with it in your initial "solved" configuration:
B D2 F' L R2 F2 R' U' L' R2 B D' R' L' U D2 R F D' B' D B' F' L2 U

I will use Daniel Beyer's naming scheme for stickers, or at least I
learned it from him so don't bash him if someone else invented it.
When I say three letters for a corner, or two for an edge, the first
letter I mention is the sticker I am describing. So if I say "UB" I
mean the U sticker of the UB piece. If I say "UFL" I mean the U
sticker of the UFL corner.

Ok so I start at UB and here are my cycles:
Edges: (UB->DL->BU)(UL->FD->RD->RB->DB->FU->LU)(BL<->RF)

I consider the DL and the FU pieces to be "flipped". This is because
notice that the DL piece goes to the BU spot and not the UB where I
started. Same for the FU piece which goes to the LU and not the UL
where I started. So I also memorize that DL and FU are "flipped".

Corners:
(UBL->FDL->FDR->BUR->BUL)(UFL->UFR->FUL)(DBL<->DBR)

Again by the same reasoning as for the edges I consider the BUR and
UFR pieces to be "unbalanced". BUR must rotate coutnerclockwise for
me to call it balanced and UFR must rotate clockwise. So I memorize
those two also.

Now I have memorized the cube, so I start solving.

1) Balance all unbalanced pieces.
edges: D x M' U M' U M' U2 M U M U M U2 x' D'
corners: L U L' U L U2 L' R' U' R U' R' U2 R

2) solve corners
(UBL->FDL->FDR->BUR)(UFL->UFR)(DBL<->DBR)
a) UBL->FDL->FDR : F' R' B2 R F R' B2 R
b) (UFL<->UFR)&(DBL<->DBR) : B2 F R' F' L F R F' L2 B' R B L B' R' B B2
I realize this isn't a commutator really. On the 5x5x5 I would do
this with the same alg, so it's one of the few cases where I don't use
a commutator.
c) I am left with (UBL<->BUR) and I remember this as parity in the
corners.

3) solve edges
(UB->DL)(UL->FD->RD->RB->DB->FU)(BL<->RF)

a) (UB<->DL)&(BL<->RF) : Done with 2 commutators
first: L U' F' E F U' F' E' F U2 L'
second: F' U2 F' E F U2 F' E' F2

b) UL->FD->RD : M' U' M D' M' U M D

c) UL->RB->DB : B L' E L U' L' E' L U B'

this leaves me with UL<->FU which is parity in the edges.

On the 3x3x3 I'd do this to fix parity: M' R' leaving an arrow PLL.
So the whole alg is : M' R' F2 U F2 U F2 U'R' U' R F2 R' U R M R

----------------

Again this method is not new, but I'm starting to try to explore how
fast it can go both on 3x3x3 and 5x5x5. It's a much better 5x5x5
method than a 3x3x3 method I've found so far, because you can execute
commutators so much faster than orientation algs when on the 5x5x5 and
going a bit more slowly because it's BLD.

Just wanted to provide an example in case anyone else is doing this,
or something like it too. I know Daniel Beyer is, but I figured I'd
put a post up here too in case anyone else was interested or already
did this.

My biggest problem right now is with those "unbalanced" pieces which
have "off" orientation for the smaller cycle group they are in.
Memorization is weird because I'm used to orient first and thus pieces
and not stickers. I can sometimes memorize just as fast as with my
old method using my images as from big cube BLD.

Solving is a lot slower, and memorization is almost always slower, but
I do occasionally memorize just as fast as with my current regular
method. My fastest times are sub-2:30 using this method, but I
occasionally get times over 4 minutes too. Once I get faster at
seeing the commutators with orientation and not just position I think
this method will be fast.

Chris