This is a tool to generate all 3x3x3 positions that satisfy a certain set of constraints.

Constraints:Display style:

Number results?

Semi-random order?

Position Limit

This is a 3x3x3 constraint solver. That means you will define some constraints (things that must be true) and this program will find positions that satisfy those constraints. If the number of positions is under a limit - currently 10000 - all positions will be printed.

You can choose how the positions will be printed. "ACube" is a format suitable for insertion into ACube. "VisualCube" gives some links to images visualizing each position. "Scramble" gives a scramble that ends up in each position. "Cube Explorer" is like scramble, but the format is closer to the one that program uses. "Raw" is an internal Javascript format, and "None" doesn't print the positions at all, but just how many there are. Note that "Scramble" or "Cube Explorer" will be pretty slow, since the program has to actually find a move sequence for each position.

The "Number results?" checkbox gives a number before every position that gets output. The "Semi-random order?" checkbox adds some randomness to the order positions are found in, which means the first position in the list will be a random position that satisfies the constraints, and the order won't be the same every time.

The "Position Limit" limits the number of output positions. It also controls how many positions will be kept in memory as things are being computed, and thus how long the whole process will take. If any internal limit is hit, there's no guarantee this is the exact number of output positions. However, increasing this number should increase the number of output positions, until they are all returned.

The constraints are the most complicated part. Constraints can be separated by either new lines, or a semicolon. Spaces don't matter. Here are the types of constraints you can use:

- Declare a bunch of pieces to be solved. Use one of these and some number of pieces will be solved all at once. Available commands:
- cross = cross on D
- F1L = D layer
- F2L-2 = first two layers on D, except for FL and FR pairs
- F2L-1 = first two layers on D, except for FR pair
- F2L = first two layers on D
- F1B = one roux block (everything except U, R, M layers)
- F2B = two roux blocks (everything except U, M layers)
- 2x2x2 = 2x2x2 block on BLD (everything except U, R, F layers)
- 2x2x3 = 2x2x3 block on DL (everything except U, R layers)

- Determine the orientation of all pieces of a given type. You can use EO, CO, EP, or CP. For instance CP means all corners are correctly permuted (in the proper position) but not necessarily correctly oriented.
- Constraints on a single location. These are all of the form [location name]=[constraint]. Location names and piece names are expressed in the same way, saying the faces that location/piece is on - an edge will have two letters (e.g. UF) and a corner will have three letters (e.g. UFR). You can also specify multiple constraints on the same location separated by an | ("or"), which means any one of the constraints will be satisfied.
- URF=UBL = the location URF is filled with the piece UBL, with the permutation given by the first letter (in this case the U sticker is correct)
- URF=UBL(?) = the location URF is filled with the piece UBL, in any orientation
- URF=(+) = the location URF is filled with some piece with a +1 orientation, that is, rotated clockwise. You can use (0) for a solved orientation, (+) or (1) for a clockwise orientation, and (-) or (2) for a counterclockwise orientation. For an edge either of the unsolved orientations is okay.
- URF=?U? = a single sticker is known for this piece. The question marks let you show which sticker is constrained, so that here, the sticker on the Right side of URF belongs on the Upper face.

- "Symmetries" which essentially define what we can do to a position without changing what position it is. For instance, when looking at last layer positions, it's common to say that you can adjust the Upper face (AUF) before or after you do the algorithm, and when viewed in that way, there are 21 PLLs instead of 287.
- Pre-AUF = allow any adjustment of the U face (here U can be any of the face letters, UFRBLD) before the algorithm
- Post-AUF = allow any adjustment of the U face (here U can be any of the face letters, UFRBLD) after the algorithm
- Inverses = allow inverting the algorithm
- Mirror-FR = allow mirroring the algorithm. There is a location shown here which can either be an edge or a corner. If it's an edge (like UR) it means we mirror an algorithm around that edge, so for UR we swap the F and B faces, but keep U and R (and D and L) the same. If it's a corner (like UFR) it means we mirror an algorithm around that corner, viewed from the location of the first sticker, so for UFR we swap F and R (and similarly B and L) but keep U and D the same. Don't worry about this too much, because if you allow pre- and post-AUF, mirroring around any U piece will do roughly the same thing.