Reference
About rubiks[dot]seanfunk
A place to learn the cube properly, look up any algorithm, and get advice about the cube in front of you — built so that the things it tells you can be checked rather than trusted.
What this is
Four learning tracks, from a first solve through to material most people never bother with; a library of 268 cases with 569 algorithms between them; a page where you describe the cube in your hands and get told what to do next at the level you asked for; a trainer that remembers which cases you keep fumbling; and a timer that measures what competitions measure.
It is written for someone who wants to understand the cube rather than be walked through it. That means the lessons say what a step is for before saying what to do, and it means the reference pages are longer than they strictly need to be. If you would rather be handed six algorithms and left alone, the beginner track will do that and stop.
Two conventions run through the whole site, so that nothing contradicts anything else: the white cross goes on the bottom and the last layer is yellow, and turns are
written in the standard notation — U R F D L B, a ' for
anticlockwise, Rw for a wide turn, M E S for the slices and x y z for
whole-cube rotations. There is a full notation reference if any of that is new.
How it checks its own work
Algorithm lists on the web are copied from one another, and a typo introduced once propagates for years. There is no editorial process that catches this reliably, because reading an algorithm does not tell you what it does. So this site does something else: it runs them.
One
There is a working cube inside the site
Not a picture of a cube — a model of one. It knows where all twenty moving pieces are, which way round each of them is sitting, and exactly what any turn does to all of them. Give it a sequence of moves and it will tell you the state of every sticker afterwards. Every other claim on this page rests on that one piece of machinery, and it has its own tests: turning a face four times must return the cube to where it started, a sequence followed by its own reverse must change nothing, and so on.
Two
Every algorithm is executed and checked against what its set claims to do
Each set of algorithms comes with a promise. A PLL algorithm promises to move the last layer's pieces into place while leaving the first two layers untouched. An OLL algorithm promises to turn the whole top face one colour without disturbing anything below it. An F2L algorithm promises to fill one slot without breaking the cross or the other three slots.
So each algorithm is run backwards from a solved cube to produce the case it is meant to solve, then run forwards on that case, and the result is inspected against the promise. A mistyped move almost always breaks one of these checks — the layers underneath end up disturbed, or the top face does not come out one colour. When that happens the build fails and the page never gets published. Where a case lists more than one algorithm, the alternatives are checked against the primary one too, which catches a variant pasted under the wrong case.
Three
The pictures are computed from the moves, not drawn beside them
The usual way to publish an algorithm is to write the moves in one place and draw the case diagram in another, which means there are two copies of the truth and they can drift apart. Here there is one. A diagram is produced by taking a solved cube, running the algorithm backwards on it, and colouring in whatever comes out. The picture cannot disagree with the algorithm, because the picture is the algorithm.
Nobody drew that diagram. It is what a solved cube looks like once that algorithm has been run backwards on it — which is precisely the position the algorithm solves.
Four
Completeness is checked against cases worked out from first principles
Checking that every algorithm is correct still leaves the possibility that one is missing. So the cube engine is asked to generate every case that can exist, from the rules of the puzzle rather than from any published list. For the last layer's orientation: corner twists must add up to a multiple of three and edge flips must come in pairs, and working through every legal combination and grouping together the ones that differ only by a turn of the top face produces exactly 57 cases. The same argument gives 21 for permutation and 41 for filling a single slot.
Every case in the library is then labelled by the same machinery and the two lists are compared. A case in the theory with nothing to solve it is a gap; two cases sharing a label are duplicates. Both fail the build. The familiar numbers below are therefore not copied from anywhere — they are recomputed every time the site is built, and the library is held to them.
What the checking does not prove
It proves that an algorithm does what its set says it does. It does not prove that it is the best algorithm for the case, the most comfortable one for your hands, or the one you should learn first. Recognition notes, finger-trick advice, the order lessons are taught in and every recommendation on the site are editorial: written carefully, held to a house style, and capable of being wrong. If something here reads as false to you, it may well be.
What this site does with your data
Nothing leaves your browser
There are no accounts and nothing to sign up for. There is no analytics, no tracking, no advertising, and no third-party script of any kind — the pages load nothing from anywhere except the site itself.
Your progress is stored on this device
Which cases you have drilled, which lessons you have marked done, your solve times and your appearance settings all live in this browser's local storage. They are never sent anywhere, because there is nowhere to send them: the whole site is a set of static files with no server behind it. Clear your browser data and it is gone, and it will not follow you to another device.
Names and trademarks
This is an independent project. It is not affiliated with, endorsed by, or connected to the owners of the Rubik's trademark, and it uses none of their branding — no logos, no packaging, no product imagery. The word appears here only where it is the ordinary name for the puzzle, in the way anyone would use it in a sentence.
Every diagram on the site is generated by the code described above, and every illustration is original. The algorithms themselves are, for the most part, the shared property of the cubing community — worked out and published over forty-odd years by a great many people, and free for anyone to use.