Pixeling, Or, Putting Hearts on Your 7x7x7

Pixeling is a technique that I discovered to make certain types of pretty patterns on NxNxN cubes. It affects the centers, only, in a large series of 3-cycles. Specifically pixeling is used to generate patterns where a certain shape of centers is moved in two 3-cycles, from (say) the U->R->F faces and D->L->B faces, in a very efficient way. An example is the hearts picture at left, which can be created with just 11 block turns (i.e. turns of a group of adjacent slices all in the same direction)! If you ask me that's ridiculously efficient.

Here's the motivation (with pictures below). You'll need to try these patterns out to understand where pixeling comes from. First we start with the basic center pattern on the 3x3:
M E' M' E.
This just moves the centers around. We can also do this on the 5x5 (or any NxNxN cube, really):
2-4r' 2-4u 2-4r 2-4u'.
But on the 5x5 there are related patterns. The following show that you can move blocks of centers around (or a single center), and that the blocks don't even need to be contiguous:
2-3r' 2-3u 2-3r 2-3u'
(2R' 2L) (2U 2D') (2R 2L') (2U' 2D).

You can basically now make any pattern we want using a series of these block maneuvers, and the efficiency on those patterns is not bad at all. But we can do better. Try this maneuver on a 5x5, which creates the staircase pattern to the left:
2R' 4U 3R' 3U 4R' 2U 2-4r 2-4u'
This is the most introductory example of pixeling. Do you see what is happening there? It's a bit tricky, but try to keep track. Every time we do a U turn, we are basically storing a line of three centers on the L-face. Together, those lines make the entire center (and the shape that we want to pixel in, which is inside it), which is done when we make the 2U move. Then we simply return the vertical slices to their original position and move all the horizontal slices back. This can also be done using the vertical R slices to store the center lines in the D face, of course, and some patterns turn out to be more efficient one way than the other, so it's important to try both ways.

We're not limited to just R' turns, though - sometimes we want to use R slices to remove a center from our shape. To the left is an arrow shape for the 7x7 that can be created like this:
2-6r' 4U 2R 2L' 3U 3R 3L' 2U 2-3d' 4R 2-6u'
Notice that before every time we do a turn of a horizontal slice in the U direction, we set up the R slices so that only the ones which contain the centers we want in our shape are misaligned. Also, this time we didn't do the U slices in order, but this is also fine; the pixeling maneuver still works.

The end result is that there are many, many ways to pixel any given shape. It will take a bit of trial and error to do a shape efficiently, but the efficiency can be really amazing. If you're making a shape yourself, remember to try both directions (vertical and horizontal slices to set up the shape) and a few different orders of slices. If one of those cycles in the wrong order that you want, you can just invert the pattern. Finally, let's return to that heart pattern. Here's the best we can do for the heart pattern with blocks and with pixeling, respectively:
Blocks: (2R' 2L 3-4u 2R 2L' 3-4u') (3R' 3L 2-5u 3R 3L' 2-5u') (4R' 3-6u 4R 3-6u') (16 moves)
Pixeling: (3-4u 2R' 2L 2-3d' 4R' 2D 2U 3R' 3L 2-5u' 2-6r)' (11 moves)

Happy patterning! Thanks go to Werner Randelshofer for the cube animation applets and to Joël van Noort for his NxN ImageCube (which I used to generate the images you see here).


How to Solve 6x6+ (on hi-games)

Let's start by saying that I don't really like the "grip shift" controls. Thus, the way I solve big cubes is designed to be somewhat fast (although I'm sure there are faster ways out there) while changing the grip as few times as possible. As it turns out, reduction is the best method for this.


Obviously, centers require lots of face turns, but also lots of slice turns. So how can we solve them with a small number of grip shifts? As it turns out, we can do a pretty decent job using U, F, D, B, and any r and l slices. Only build and insert rows on the x axis (faces U, F, D, and B), and although this uses a lot of cube rotations it isn't too restrictive. Besides, you can only see U and F anyway. So then the question is what slices we need. Here's how I do it:
6x6 and 7x7: shift both right and left in once. Now you can do all of the usual moves (3r, 3R, 2r, 3l, 3L, 2l) with each hand.
8x8 and 9x9: shift right in twice and left in once. The left hand can do 2l, 3l, 3L and the right hand can do 4r, 3r, 4R.
10x10: shift right in three times and left in once. The left hand can do 2l, 3l, 3L and the right hand can do 5r, 4r, 5R. Note that 4R is actually not possible (except by doing 4r y2 3l'), so you should try to work around this when building centers.

Note that in the cases where the right and left hands are asymmetrical, I really suggest pairing from the inside out, since slice moves are not always possible or convenient. The goal is to avoid cube rotations so you can spend all your time actually doing moves. As with other large cubes, by the way, I really suggest pairing up 1x(n-1) rows of centers, and putting them together as soon as they are done.


My method for edges is worse, but it still works pretty acceptably. The way I do this is to use the D slice to do slice moves and pair up edges on the E slice, since I tend to use the other slices to move edges around. Currently I use WO for moving the D slice in (up) and SL for moving it out (down), but you can use anything you want. Then I pair up edges multislice-style: I start by pairing up the innermost pieces, and then move out. Note that it's also possible to just use the L slice (and pair up edges on M), and use only RUDFB moves to insert edges, but personally this doesn't feel natural to me so I don't use it.

My method of pairing up 5x5-style edges is freeslice (the bigcubes.com) style, which means I pair up one edge group (of 3 pieces) at a time and don't fix centers until I have eight edges paired and out of the E slice. Since this normally requires U moves, I end up doing a LOT of z2 moves. As I said, this isn't the best way to pair up edges, but it works. Note that if you end up with a parity case you are better off temporarily moving the edges to the M slice, shifting R and L in by an appropriate amount, and doing the parity normally. This is possible because you don't need to do single-layer R and L turns.

So I pair up edges in two steps on 6x6 and 7x7, three steps on 8x8 and 9x9, and four steps on 10x10. On the last step, I just use the standard 5x5 pairing (which is on M), because if I have the right and left grips on the far outside of the cube I can do slice moves AND R and L turns.


The 3x3 stage is pretty standard, press space and just solve it normally. On even cubes there are parity issues to deal with. The way I do this is, for OLL parity, shift L and R in until the r and l slices turn half of the cube, and then the algorithm is:
r U2 x r U2 r U2 r' U2 l U2 r' U2 r U2 r' U2 r'
and for PLL parity, just shift R in so that the r slice is halfway, and then do:
z r2 z' r2 U2 r2 y2 L2 y2 U2 r2 z r2 z'.
There are a lot of cube rotations so it looks longer than it is, but it's still kinda slow.

So, good luck with bigcubes! Make sure to give each one a try, because for a lot of them you'll get on the top 100 list if you solve it, no matter how long it takes.