Live Chat
Rubic's Cube Kirjava's 4x4x4 'K4' Method

Rubic’s Cube Kirjava’s 4x4x4 ‘K4’ Method

This method is derived from Per’s ‘cage’ method. I like this method a lot but my biggest problem with that was the centres at the end, so I stuck this part nearer the start when you have more freedom. It relies on commutators quite heavly so I will try and show you some examples with each picture when needed. A nice advantage is that you only have one parity (you can even use a parity alg from the centres-edges-3x3x3 method, the OLL one) and that you don’t have a 3x3x3 stage at the end, which is a plus for all the corners first people 🙂

I invented this while coming back from a cube meetup. My times were around 3:00 (using the cage method) and using this they dropped to around 2:00 with me breaking my PB (set with a centres-edges-3x3x3 method) of 1:43 with about an hour after it was conceived.

Lower case letters denote single layer turns.

Method Outline

Here we have a scrambled cube. The first thing we are going to do is make a ‘Roux Block’. By this, I mean create a 1x3x4 block like in the picture below. I usually do this by getting a centre (white) and just adding the edges like you’re making one layer. This is quite trivial to do and requires little thinking. I build the same block for better colour recognition later on, but neutrality may help in some lucky cases and opposite colour solving. I usually build the block on L.

Once we have the 1x3x4 block done, we move on and solve the centres. I use Stefan Pochmann’s method for this part, but execute it differently generally. Firstly I keep the 1x3x4 block on L and solve the centres in the l layer/ring. This is practically the same as stefan’s method, but make sure you only use <l,r,R,U> to solve them as to preserve the 1x3x4 block. Then when doing the rest of the centres, I place the 1x3x4 block on D with the free part in the B layer. I shoot the centres from U onto the B face with LlU’Ll’ and Rr’URr. An advantage for this is that you can see pretty much every edge apart from the one you are solving, so it is good for looking ahead. When you’re going to solve a face, always move it to B then shoot the centres in U to B while looking at the next centre you’re going to put in. If the U centres are solved and the rest of the cube isn’t, simply get a dodgy centres from the E slice into U with one of the moves or directly solve it.

This is just the way I have found to do it easily. Another good way is to the the generic method of keeping the 1x3x4 block on L and solving the R centres before the ones in the M slice. Or using Pochmann’s method and working with the F face. Completely up to you. Mistakes are easily cleaned up later on with commutators. (eg, rU’l’Ur’U’lU)

Note: The centres do not have to be in their correct orientation yet. (Orientation of a centre defined as being solved relative to the 1x3x4 – the M-slice centres can be free) They do need to be in the right order, though. Update: After reading this, read the optimisations. This will make your centres much smoother and faster.

Before you start this step, replace the 1x3x4 block back to L by rotating the cube if it isn’t already there.

Now that we have the centres done, we’re a bit more restricted with the kind of work we can do. What we’re actually doing is finishing off the first layer that we started with the 1x3x4 block. This is accomplished very easily like making a single pair in the conventional popular method. After it has been created, attempt to match it with the two corners and place it. If this is not possable, place it then just add the corners. This may be a faster way as then you can find both corners while you are placing. I usually get one corner with it before putting it with the 1x3x4 block.

The ‘Waterman’ step.

Place the first layer (completed one) on D. In this step, we are going to solve the corners. For the meek, you can use OLL algs then PLL algs. If you would like to make this step more efficient, I would say to learn/use a C*LL varient. COLL is a good one and waterman’s algs are ideal ones. I personally use CMLL due to heavy Roux usage. While this is all well and good, sometimes a piece from the D layer may find itself up in U. I have remembered these cases and can change the endings of them when i solve on the 4x4x4. You should end up with a quincunx on U. Finally, place the finished layer back on L.

In this stage we will solve all the edges pieces in the M layer leaving only the final layer on R left to complete. I do this with a combination of 3x3x3 algorithms and commutators. There will be lots of little things that you can discover yourself to make yourself go faster. I will present some examples and leave you to do the rest. I advise against learning these. Instead, learn how each one works and what it does, so you can create your own to do different things. Generally, you moves pieces from the R (last) layer to the M slice using algorithms or move them within the M slice. While I am putting in one or two edges I will search the cube for the next one I am going to put in. This step can be very fluid and very fast, you just need to work on it and take advantage of lucky cases. Make it smooth. You should generally come up with your own recognition techniques so you know what to do quickly. I compare the edge to where it needs to be inserted and the centre next to it. After this stage, put the first layer on D again to have the unfinished layer on U.

Here are some examples:

R2 – d – R’U’R – d’ – R’UR

R2 – u’ – R’U’R – u – R’UR

R2 – E – R’U’R – E’ – R’UR

R’y’ – r – BRB’ – r’ – BR’B’ – y

R’y’ – l’ BRB’ – l – BR’B’ – y

R’y’ – M’ – BRB’ – M – BR’B’ – y

I find learning by example is better than learning by tutorial.

In this step we are going to solve the edges of the last layer. This is the area of the I think I can improve on the most and optimise, personally. I suggest you learn these two following algorithms, as they are very useful; RUR’U’rR’URU’r’ and rUR’U’r’URU’R’. Again, we solve this step with commutators. Because I’m not a commutator god, I try to use the two stated algorithms and some 3x3x3 algorithms to limit the number of commutator 3-cycles of edges you have to do to a minimum. I do one or two a solve this way. Gradually though, I am finding that recognition is speeding up and the number of three cycle cases I have to ‘know’ are relatively small. I will try and explain the concepts behind creating them as best I can, but I find it difficult. I learnt how to do them from Per, and I think he would be more than happy to talk about them.

There are 2 orbitals for the 8 outer edges. Which orbital the edge is in is like the orientation of it. Doing U turns will not change the orbital of a cubie. LUf, FUr, RUb and BUl are all in the same orbital. LUb, FUl, RUf and BUr are in the other orbital.

Rarly, you will get a 3-cycle where all three edges are in the same orbital. If this happens, use the following commutator; F’ – R’ u’ R U2 R’ u R U2 – F. I’ll leave finding the mirror as an exercise.

The rest of the time, you will have a 3-cycle where there are 2 edges in one orbital, and the other in another one. Firstly, put the edge that is in it’s own orbital apart from the other two into the D layer with a half turn (eg, L2/r2). Then, you can put the edge from the other orbital that is the destination of the one currently in the D layer into the D layer with a quarter turn. Now these two pieces are in the same orbital in the D layer. You then move the one that was originally in the odd orbital to the other edge place by moving the D layer. Then move this edge back into the U layer with the opposite of the quarter turn you did before. Now adjust U so that it is in the same place as the edge you just put in D. Now you use the same move to put it back into D and then turn the D layer so that the edge goes to the place where the edge from the odd orbital used to be. Then you can do the reverse of the quarter turn again to bring the edge back to U. Then unto the U move you did to change the second one from the same orbital, and finally undo the half turn to return the edge back into the odd orbital but with the correct piece. I think you’ll need some examples now…

r2 – l D2 l’ U l D2 l’ U’ – r2

R2 – U’ r’ D’ r U r’ D r – R2

l2 – r’ D2 r U r’ D2 r U’ – l2

R2 – r’ D’ r U2 r’ D r U2 – R2

l’ – r’ D2 r U2 r’ D2 r U2 – l (Exception!)

There is only one parity in this method (because we are directly solving, the permutation parity doesn’t really exist), but it’s quite difficult. It comes up 50% of the time. You may end up with just two edges swapped. if this happens, you can use an OLL parity that just flips a single edge to solve adjacent edges, and l’U2 l’U2 x U2l’ U2r x’ U2r’ U2l2 to solve the case presented in the image. when a case comes up not like the one shown, you can use setup moves combined with one of the parities to solve it, or an alternative would be to use the quick 3-cycle algorithms from the last step to setup and do the inverse to finally fix the puzzle.

You can ask us “write my descriptive essay” on this or any other topic at Don’t waste your time, order now!


An alternative approach proposed is to solve the yellow centre after the white, then you complete the 1x3x4. This doesn’t hamper your ability to build the 1x3x4 at all, and makes the centres extremely easy to solve (I used to hate the centres part, now it’s much faster) as you can keep the 1x3x4 on L (less cube rotations), solve them like in the centres-edges-3x3x3 and not have to worry about breaking the 1x3x4 as much.

Another thing to use would be to make two pairs when you are finishing off the first layer from the 1x3x4 block instead of just one. This should automatically be preserved when you complete the corners on the non-solved side and you can move the pair as one, potentionally speeding up the M slice edges. I would advise to only do this if you can see it instantly though, otherwise you can probibly directly solve it faster.