Rubik's cube

This page is a stub.

Links

Official

• World Cube Association

Guides & Wiki

• speedsolving.com wiki
• Quel cube choisir pour le speedcubing 3x3x3
• Rubik's cube : aller plus vite avec la méthode débutant

Tip Videos

• HOW TO DO FINGER TRICKS RUBIK'S CUBE FINGER SHORTCUTS How to do finger tricks for Beginners.

Some cool finger tricks. Don't leave your finger from the cube most of the time.

• Finger Trick Exercises And Tips

More nice exercices to do (RUR'U', L'U'LU, RUR'F...)

• What a speedcuber sees when he solves the Rubik's cube.
• Tutoriel : Améliorer la croix du 3x3 (méthode fridrich)

Overshoot move: U' R' F R, swap an edge on the cross: R' u R' u'

• Tutoriel : Résoudre les F2L intuitivement

See #Tutorial section below

• Rubik's cube : Méthode intermédiaire (fridrich simplifiée)

See #Tutorial section below

• Alternatives to cube rotation [F2L Tutorial

Video on how to move F2L to FR column.

• Cube rotation: y U' L' U L. Quite slow.
• Sledgehammer: F R' F' R (or see variants below).

  A bit faster, no cube rotation. Use it for inserting your last f2l pair for partial edge control of your OLL, or to avoid moving your next pair if you've spotted it using look ahead. Apparently the F' is done with the thumb, a bit before doing the R.

• Case Number 2: F' (r U r')
• Case Number 3: r' U' R U M' — What about B' R B R' ?
• Case Number 4: l U L' U' M' — What about B L' B' L ?

• NoahCubes Edge Control Part 1: When to Use Sledgehammer

When to use the sledgehammer (right-handed left variant): R' F R F' , or "RU" prime: U R U' R' (i.e. sexy move prime).

The goal is to end up with 4 well-oriented edges in the OLL.

• NoahCubes 10 Websites Every Cuber Should Know

http://cubesolv.es/ (reconstruction db for WR...), speedsolving.com forum and wiki, alg.cubing.net, wca, www.qqtimer.net

• F2L - The Jessica Fridrich Method - No algorithms needed.

Solutions

• Bob Burton's CubeWhiz (CFOP, F2L...)

  Notations

• F2L
  • Advanced F2L on speedsolving.com

Shops

• Lubix Cube (USA)

Sell the recommended lube lubix's lube, but oversee, so high shipping and custom cost.

The Lubix silicone is made of a polydimethylsiloxane polymer. Note this is the same lubricant that Rubik's sell in their Rubik's Speedcube Pro Pack.

• Cubikon (Germany) (google translated)
  • Does not sell lube in tube (only spray, reputed bad)
  • Sell Zhanchi Dayan V (10.95€)
• King's Cube (France)

Sell Maru lube (not recommended, see below), Calvin's lube high viscosity and Calvin's lube medium viscosity (seems very good).

Sell Zhanchi's cube, but not black ones.

• iCubik (Italy)
• Info
  • List of recommended and non-recommended lubricant
  • Maru lube not recommended. Dries out too quickly. ([1])

Tools

• Tools on Rubik's cube (algorithm mirror, rotation remover)
  • qcube v2 (cube simulator)

z = U            p = z       h / g = F / F'
r = Lw', l       q = z'      i / k = R / R'
t = x'           j = U       d / e = L / L'
y = x2           m = r'      j / f = U / U'
u = Rw, r        x = U'      s / l = D / D'
i = R            v = l       w / o = B / B'
                                           
space = scramble             a     = y'    
                             n / b = x / x'

• alg.cubing.net — Great & clear cube visualizer, view your moves, simplify & mirror them.

On GitHub. Installed locally at http://localhost/alg.cubing.net/index.html.

Apps

Android

Games

• Cube Rubik

A rubik's cube game. A bit though to manipulate.

Timers

• Rubik's Stopwatch

A simple speedcubing timer with scrambler algorithms support. Very nice design, all on one single page. Best out there.

• SpeedCube Timer Free (Rubiks)

A timer for speed cubing. Some ads and no much features.

• SpeedCube Timer

A timer for speed cubing. Scramble algorithm. No graph.

• Speedcuber Timer

A timer for speed cubing. Scrambe algorithm. No graph. Compare cube brands. Too many pages.

• Sune Timer

A timer for speed cubing. Scramble algorithm. Graph. Design not as good as Rubik's Stopwatch. Additional resources like algo, WCA regulations.

• plusTimer

A simple, elegant timer with WCA scrambles for recording Rubik's cube solves. Graph and history by session (best, best AO5), scramble image, double touch inspection.

Solvers, Algorithm database

• Rubik's Cube Fridrich Solver

Solver (manual input or via camera). List of solving algorithms.

• Rubik's Cube Algo Reminder

A big database of all possible sequence for each category (PLL, OLL, F2L...). Support for 'favorite' flag, adding new category and new algorithms.

• Badmephisto

Simply a big page with all solving algorithms, clear and well-designed. Must have.

PC

• TNoodle
Official WCA's scrambler, showing final cube state. Include a very nice timer application. Download TNoodle:

git clone https://github.com/cubing/tnoodle.git

./tmt graph --description                 # To get a list of available target

Timer

Timer application is only available up to v0.8.7.

git checkout v0.8.7
./tmt make dist timer
sudo cp -r timer/dist /usr/local/bin/tnoodle-timer
chromium-browser /usr/local/bin/tnoodle-timer/tnt.html           # To start the javascript timer

In old version, timer is available as a .jar file. For instance:

git checkout v0.7.14
vi tmt
# Comment line with
#                args += [ '-Werror' ]
./tmt make dist timer
java -jar timer/dist/TNoodleTimer.jar 
# Then visit http://127.0.0.1:8080/tnt/ or http://127.0.1.1:8080/tnt/ (or possibly port 2014)

• Data for the javascript tnoodle-timer is stored in chromium local storage:

On the disk

~/.config/chromium/Default/Local Storage
  __0.localstorage
  __0.localstorage-journal
  chrome-extension_pafkbggdmjlpgkdkcbjmhmfcdpncadgh_0.localstorage
  chrome-extension_pafkbggdmjlpgkdkcbjmhmfcdpncadgh_0.localstorage-journal

Or better, in chromium, open developer tools by pressing F12,then

• Export timing data — Go to Console tab, then type localStorage.sessions to get the content of the array, and save the results.
• Import timing data — Go tot Console tab, then type localStorage.sessions="XXX" where the XXX is replaced by the result saved previously, but with all double-quotes escaped. These can be escaped for instance with

sed 's/"/\\"/g" sessions.txt > sessions-escaped.txt

Sessions data is also available in the Ressources tab, but long values get truncated, and hence this is not suitable method for import / export.

• To install tnt in lighttpd (example on lacie-cloudbox):

vi /etc/lighttpd/lighttpd.conf

Add the lines

## Added for rubik's WCA official scrambler / timer
alias.url += ("/tnt" => "/opt/local/tnoodle-timer/tnt.html" )

Copy all files to /opt/local/tnoodle-timer/

Then open browser at http://lacie-cloudbox/tnt/ (Firefox or chromium works best it seems, Opera only works via file: access)

Other TNoodle apps

• BLD
• scrambler
• qqtimer (the most used timer it seems) (qqTimer on GitHub)

Notation

• Cube rotation x, same as R but whole cube
• Cube rotation y, same as U but whole cube
• Cube rotation z, same as F but whole cube

Acronyms:

LH

Left-hand

RH

Right-hand

SH

Sledgehammer

Sequences

We call a move a permutation on the cube that can be done in a single movement. This can be the rotation of a face by 90° or 180°, but also rotation of a middle layer, two layers, or the whole cube. Each move has a dedicated letter, with a prime indicating the reverse movement.

A sequence is a small serie of moves that is frequently used to build up more complete algorithms. Typically these sequences are done very rapidly. Fast algorithms are those that link several sequences with an easy transition (no re-gripping, cube rotation, etc).

The inverse of a sequence is the sequence that cancel the effect of that sequence. We use prime to denote that sequence.

A mirror sequence if the L-R symmetric sequence (i.e. F changes to F', R changes to L', etc)

Sexy move

• Direct: R U R' U' (prime: U R U' R')

Sledgehammer

• Right: R' F R F' (prime: F R' F' R)
• Left: L F' L' F (prime: F' L F L')

Note: If we do this sequence with the right-hand (after cube rotation y'), we get y' F R' F' R, which is the same as Right prime.

Overshoot

• U' R' F R

Tutorials

F2L

Source: Tutoriel : Résoudre les F2L intuitivement

The principle is to always fall back in one of the 4 basic cases. A basic case is one that requires only 3 moves to solve:

• Case /R1/: R U' R' and case /L1/: L' U L (mirror)

Pair next to each other, horizontal and left (right) of target slot.

• Case /R2/: R U R' and case /L2/: L' U' L (mirror)

Corner above target slot, edge on UB. Corner white sticker facing right (left), front sticker same as edge up sticker.

Notes:

• Always put the corner above the slot, and solve from the right side first, then switch to left if necessary.
• In algorithm below, whitespaces indicate that we reached a basic case.
• We can always replace U2 R U' R' with U sledgeR'.
• Case solve are coded for fast reference. (R2, BR) means we want to get a basic case /R2/ by bringing the corner above BR corner. (R2, BR, rot) means we aim at obtaining a /R2/ case by using the BR corner, but this time with rotation of the corner; this means that the corner is moved above the BR corner not using a U move (followed by R ... R' that would preserve orientation of the corner), but with a R moves that changes orientation of the edge. So rot indicates that the solves change the F2L family.

There are 3 F2L families: sticker UP, sticker FRONT, and sticker RIGHT.

White sticker UP

• Edge on 2L:

(2L1) Case 1, edge wrong (matching corner color) Get the pair out, then reinsert R U2' R' y U2 (L' U L) (alt. R U2' R' U' F R' F' R') Faster, FR: U' R' F R F' R U' R' Faster, FL: left SH, or y', the subcase FR above. Faster, BL: Victor uses L U' L' y' L' U2 L (B with RH index). Faster, BR: usual is R' U R' F R F' R, Victor uses R' U R d' R U' R' ({{{1}}}.

(2L2) Case 2, edge correct (not matching corner) sexy sexy sexy.

• Edge on LL, not touching: we get a basic base by (i) bring edge to its color, (ii) raise empty slot, (iii) bring corner above the edge, then (iv) turn back slot. All cases below are identical.

• (LLBU1) Edge on BU, case 1: U R U2' R' R' F R F'
• (LLBU2) Edge on BU, case 2: y U2' L' U' L L F' L' F
• (LLLU1) Edge on LU, case 1: U2 R U R' R' F R F'
• (LLLU2) Edge on LU, case 2: y U' L' U2 L L F' L' F

• Edge on LL, touching:

• (LLRU1) Edge on RU, side color not matching (R2, BR, rot): create a /R2/ case by using BR corner with R move, and U2, R U2' R' U' (R U R').
• (LLRU2) Edge on RU, side color matching (LLBU2, BR): fall-back to case (LLBU1) using BR corner with U' then R, U' R U' R' U' y L' U' L (L F' L' F).
• (LLFU1) Edge on FU, side color not matching (L2, FL, rot): create a /L2/ case by using BL corner with y L' move, and U2, y L' U2 L U (L' U' L) y'.
• (LLFU2) Edge on FU, side color matching (LLLU1, FL): idem, fall-back using BL corner (with y U then L' ), y U L' U L U y' R U R' (R' F R F').

White sticker FRONT

• Edge on 2LL:

Case 1, edge correct Can this case be be inserted from any angle without cube rotation? (R1, BR) goal is to get a /R1/ using BR corner, U' R U' R' U2 R U' R'. Faster, no y / y' , FR:

Case 2, edge wrong (L2, BR) goal is to get a /L2/ using BR corner, U' R U R' U y L' U' L. Faster, no y / y' , FL: y U2' L F' L' F U2' L' U' L y'

• Edge on LL, non-adjacent

• Case 1, same U color, edge BU (R1, BR): Goal is to get a /R1/ using BR corner, U' R U R' U2 R U' R'

Idem for edge LU (R1, BR): U' R U2 R' U2 R U' R'

• Case 2, different U color, edge BU (L2, BR): Because U color are different, goal is to get a /L2/ case here using BR corner: y U L' U' L U' L' U' L (or U' R U' R' U y L' U' L).

For edge LU, this time we directly have a /L2/ (L2): y L' U' L

• Edge on LL, adjacent on RU

• Case 1, same U color (R1): we have directly a basic case /R1/, U R U' R'.
• Case 2, different U color (L2, BR): so we want to get a /L2/, using BR corner: U' R U2 R' U y L' U' L.

• Edge on LL, adjacent on FU

• Case 1, same U color (R2, FL, rot): we use FL corner to get a /R2/ : y L' U L U2' y' R U R'
• Case 2, different U color (R2, FL): we use FL corner to get a /L2/: y U L' U L U' L' U' L

White sticker RIGHT

• Edge on 2LL 2LL:

Case 1, edge correct This case can actually be inserted from any angle without cube rotation. (L1, FL) mirror of above, get a /L1/ using FL corner, and U then L' move: y U L' U L U2' L' U L y'. Faster, no y / y' , FR: U R U R' U2 R U R' Faster, no y / y' , BL: U L U L' U2' L U L' Faster, no y / y' , FL: U L' U L U2' L' U L (alt using sledge: U L' U L L F' L' F, F with thumb) Faster, no y / y' , BR: U R' U R U2' R' U R

Case 2, edge wrong (R2, FL) mirror of above, get a /R2/ case using FL corner, and U then L' move: y U L' U' L y' U' R U R' Faster, no y / y' : U2 R' F R F' U2 R U R'

• Edge on LL, non-adjacent

• Case 1, same U color, edge BU (L1, FL): Here the best is to solve FR then send it to BR y' U R' U' R U' U' R' U R y (alt: y' U R' U' R U' y F R' F' R or y U L' U' L U' L F' L' F y').

idem for edge LU (L1, FL): y' U R' U2 R U' U' R' U R y (alt: y U L' U2 L U' L F' L' F y').

• Case 2, different U color, edge LU (R2, BR): we need to shift our edge by a single U move: U' R U R' U R U R'

For edge BU (R2): this time we directly get a /R2/: R U R'

• Edge on LL, adjacent on RU

• Case 1, same U color (L2, BR, rot): we get a /L2/ case using BR corner and R U' move, R U' R' U2 y L' U' L y'
• Case 2, different U color (R2, BR): we get a /R2/ case using BR corner and U' R move, U' R U' R' U R U R'

• Edge on LL, adjacent on FU

• Case 1, same U color (L1): we directly have a basic case /L1/, L' U L
• Case 2, different U color (R2, FL): so we want to get a /R2/ case. We can with FL corner, y' U R' U2 R y U' R U R' (or y U L' U2 L U' y' R U R')

Corner on 1L

White sticker DOWN

	Le Belge (front right) Beginner solution U R U' R' y U' L' U L y' Using inverse SH U R U' R' F R' F' R		Le Belge (front left) Beginner solution U' L' U L y' U R U' R' y Using inverse SH U' L' U L F' L F L'
	Le Belge (front right - alt)		Le Belge (front left - alt) Faster (no y / y') R U' R' U' R U' R' U R U R' (grip: LH F/B, index doing all U' and first U, RH U/D, index 2nd U) (R U' R' to create a known F2L case) Faster (no y / y') U' R' F R F' R U R' (with a sledgehammer, 2nd U with LH index)

White sticker on FRONT / RIGHT face

• First move edge on its color, then
  • If white sticker is on the SAME face → use a double sexy or sexyL.
  • If white sticker is on DIFFERENT face → use a TRUNCATED double sexy' or sexyL' , where first UP rotation is skipped.
• Cases are identified by the visible colors on corner and lateral color on the edge. This is useful when solving the F2L in the wrong slot.

	col-white R-col sexy sexy (alt. U2 L' U L y' R U R')		col-white F-col y sexyL sexyL y' (alt. U2 R U' R' y L' U' L y')
	white-col1-col2 R U' R sexy' (best grip, RH: front/back, index to prepare for U) (alt. R U' R' R' F R F' or y L' U2 L y' R U2 R')		col2-col1-white y L' U L sexyL' y' (alt. R U R' U' F R' F' R)

More tricks

Tutoriel F2L avancés - Partie 1 (déconjugaison intelligente)

• Déconjugaison intelligente

Tutoriel F2L avancés - Partie 2 (Insertions sous différents angles)

• Avoid y2 moves, but solve the F2L cases as is (with empty slots in the back).

This is true for all "base" cases, both contiguous and not.

• y and y' is ok. When choosing between both, favor the one that leads to R and U moves.

For instance, better do y' R' U R than y L' U L to insert a base case.

Tutoriel F2L avancés - Partie 3 (Utilisation des slots libres)

• Use free slots

Tutoriel F2L avancés - Partie 4 (Eviter les rotations y et y')

• Goal of this part: Avoid y and y' move whenever possible.
• Introduce another commutator, the sledgehammer: R' F R F'

F' move must be done with the right thumb!

• Case: R U' R y L' U2' L y', white sticker UP, FR corner.

Subcase FR. Use sledgehammer U' R' F R F' R U' R'

Subcase FL. Use left sledgehammer, or y' then subcase FR above.

Subcase BL. Use L U' L' y' L' U2 L. Or sledgehammer also possible, but with re-grip (B with right hand index).

Subcase BR. Usual solution is R' U R' F R F' R, but R' U R y U' R U' R' (U' while y) is also ok.

• Case: U y L' U' L U' y' R U R'

Avoid cube rotation with sledgehammer: U2 R' F R F' U2 R U R'

• Case: U y L' U L U2' L' U L y'

Can be inserted from any angle. Either pick contiguous base case or separated.

If corner in FR or BL: U R U R' U2 R U R' or U L U L' U2' L U L'.

If corner in FL or BR: U L' U L U2' L' U L (alt using sledge: U L' U L L F' L' F, F with thumb) or U R' U R U2' R' U R

• Case: corner on D face

See my shortcuts above with sexy moves above.

• Case: le Belge

When corner in FRD, and correct edge on UR, two solutions:

• R U' R' U' R U' R' U R U R' (grip: LH F/B, index doing all U' and first U, RH U/D, index 2nd U) (R U' R' to create a known F2L case)
• U' R' F R F' R U R' (with a sledgehammer)

Android - Fridrich Solver (Algorithms summary)

• This app shows solutions for all F2L cases.
• FAST: Use d and d' move instead of y' U or y U'. This happens extremely frequently, and is very useful to solve pair in any slot without turning the cube.

Fridrich simplified

Source: Rubik's cube : Méthode intermédiaire (fridrich simplifiée)

4 steps:

• Cross
• F2L
• 2-look OLL
• 2-look PLL

For F2L, see tutorial above.

For 2-look OLL, first do the cross:

• Line shape: F sexy F' (F' with the thumb)
• L shape: f sexy f' (f' with the thumb)
• no shape: do 1st then 2nd algorithm

Then we do one of the 7 OLL "cross" algorithms. The cases are denoted by the position of yellow sticker for each corner, starting from FL, the FR, BR and BL corner. So UFRB means the yellow sticker facing upward for the left-front corner, facing front for the right-front corner, facing right for the right-back corner, and facing back for the left-back corner.

• UFRB: R U R' U R U2 R'
• FRUL: R U2 R' U' R U' R' (inverse of UFRB)
• FFUU: R2 D R' U2 R D' R' U2 R' (D and D' ideally by pulling then pushing with left-hand finger)
• LRUU: x' R U R' D R U' R' D' (idem) (x' R → l, so l U R' D R U' R' D') (or variant UFBR: l' U' L U R U' r' F)
• URUB: x' R U' R' D R U R' D' (idem) (x' R → l, so l U' R' D R U R' D')
• FFBB: F sexy sexy sexy F'
• LFBL: R U2 R2' U' R2 U' R2 U2 R

For 2-look PLL, like for the 2-OLL, we first do the cross, then the corners. For the cross, turn the U face until 1 edge is good, and place it at F slot, and look how the other edges must be permuted.

• All edges are ok: congratulations ;-)
• clockwise: R' U R' U' R' U' R' U R U R2' (do R' U R' U' with right index under BRD corner, then R' U' R' U with right index next to FRD corner)
• anti-clockwise: R2' U' R' U' R U R U R U' R
• 2 edge ok: do either of algorithm above, and retry.

Then look at the corners. If one corner is good, turn the cube such that it is at FL slot, and look how the other corners must be permuted

• 1 good corner (FL), clockwise: x R' U R' D2 R U' R' D2 R2 or l' U R' D2 R U' R' D2 R2 (using x R' → l')
• 1 good corner (FL), anti-clockwise: x R2' D2 R U R' D2 R U' R l' R' D2 R U R' D2 R U' R (best grip: left thumb on D face, right thumb on F face, left ring finger to prepare the D2 / D2, right index to prepare the U.
• no good corner: do either of algorithm above, then you will have a good corner

Algorithms

PLL - swap 2 edges

• R U R' U R U2 R' U

Finger Tricks

• D2 move

Use the ring and major finger. To work well, hold the cube with index and thumb such that ring and major hits the left (or right) side of the D face almost vertically. For instance, using the left hand, the index must hold both the LBU corner and LB edge, and possibly a bit the center back face and BU edge. See this video.

Solution

We use notations from https://github.com/chrishunt/rubiks-cube:

• R, means turn Right face clockwise
• R' or r, means turn Right face counter-clockwise
• R2, means turn Right face twice.