Blindfolded solving of 3x3

Blindfolded solving a 3x3 cube means: look at the cube and remember how to solve it, put a blindfold on an solve it, take the blindfold off. Blindsolving requires a totally different approach than speedcubing. Be sure you can solve a 3x3 pretty well and know you PLL algorithms before going over this page.
First of all you have to be able to perform algorithms on a cube without looking at the cube itself. When you've got that and I'm pretty sure you already have the last thing required to solve a cube while blindfolded is your memory. It is certainly not as hard as it looks, the only thing you have to be able to do is memorize 20 things. My memory system is not very good and for that I suggest the other blindfolded sites stated on the bottom of this page, I don't really have any system at all which is very hard and not a good way to remember things fast.
So with all that said let's get to the actual blindfolded solving. A solve is done in 2 stages, solve the corners and solve the edges. You can do these in the order you like but for that see the solving/memorizing part below. First let us look at the edges

Edges

The method I use for edges is called the M2 Method invented by Stefan Pochmann. Look here for how the master does it. He also uses his R2 method to solve the corners. This is quite an advanced method, maybe I'll make a beginner edge solution here sometimes. It is highly recommended you know the Pochmann's first method first.
For blindsolving we would like to use algorithms which don't affect a lot of pieces so that it's easier to remember what happens to the cube. The original Pochmann method did 2 cycles on UR and UL (note: make sure you know the difference between the UR (which is on the U layer) and the RU (which is on the R side) stickers). Of course, as you know you can't just switch 2 cubies on a 3x3, the side effect on the original Pochmann method is that the URF and UBR stickers are switched back and forth. Roughly on M2 method you don't use the T algorithm but the 'algorithm' M2. Where as the original Pochmann method has UR as your 'buffer cubie' (the cubie that is to be solved) on the M2 method it must be one of the M slice places. Stefan uses the DF sticker for this, I use the FD sticker for this the target is automatically the BU spot. I learned the M2 method from Joel van Noort (also check his BLD tutorial Here. When I met Stefan again after I learned it I was quite surprised he actually uses the DF sticker, but it doesn't really make any difference, just that you don't think the 'algorithms' I use are wrong, I just use a different approach. So again we can't switch merely 2 edges. On the M2 method the switch algorithm M2 has more effects than on the first method. It switches the UF/FU with DB/BD and also makes that the centres are switched. Actually, like Stefan mentions, the edges are not switched at all, they are still in the same 'relation to their centre'. The result of this switching is that there are always 2 stages: the centres are good, the centres are bad. Mostly there is nothing different in the algorithms you use besides when you have to solve the UF/FU/DB/BD position and the centres are NOT good. Because the centres have changed you have to shoot to the opposite position instead, but you only notice this while solving and doesn't affect your memo. So if you have to shoot to UF and the centres are NOT good, you use the 'algorithm' that solves the DB normally but actually solve the UF. This part is the hardest part of this method for someone who doesn't know this I think. For this rarity you have to remember the edges in 'pairs', see the solving/memorizing part below for that.
Shortly: T-perm is now M2, buffer = FD, target = BU, M2 switches the UF/FU DB/BD edges + centres, shoot to the opposite position when the centres are bad, shooting to BU/UB or any other edge is always the same.
Ok now the build-up of the 'algorithms'. You might be wondering why I said 'algorithms' the whole time instead of just algorithms. This is because almost all algorithms are intuitive and build-up in a certain way, on Stefan's way of M2 method he has it all intuitive with the side effect that you might have some not-oriented edges on the edge which you have to solve. The build up of the algorithms to shoot to all R/L edges is: bring the sticker to the BU position without disturbing the M slice further, do M2, undo the setup moves. You may notice this is closely like commutators and actually, in a way they are. So for instance you have to shoot to the RD position you'd do, UR2U' (bring the piece to BU), M2 (do M2), UR2U' (undo the setup moves). So: UR2U' M2 UR2U'. Here is the table of algorithms I use, note that shooting to BU is lovely :)
Target Algorithm
LU LU'L'U M2 U'LUL'
LF U'L'U M2 U'LU
LD U'L2U M2 U'L2U
LB U'LU M2 U'L'U
UL x' UL'U' M2 UL'U' x
FL x' UL2U' M2 UL2U' x
DL x' ULU' M2 UL'U' x
BL x' L'U'LU M2 U'L'UL x
RU R'URU' M2 UR'U'R
RF URU' M2 UR'U'
RD UR2U' M2 UR2U'
RB UR'U' M2 URU'
UR x' U'RU M2 U'R'U x
FR x' U'R2U M2 U'R2U x
DR x' U'R'U M2 U'R'U x
BR x' RU'R'U M2 U'RUR'
M layer edges
BD M U2 M U2
FU U2 M' U2 M'
DB M2 D R'U R'U' M' URU' M R D'
UF F E RUR' E' RU'R' F' M2
UB F' D R' F D' M2 D F' R D' F
BU M2

Shortly this looks tough but is very easy. Only the 3 big algorithms are a bit long an need to be learned.
If you are left with 2 flipped edges you can use: M' U M' U M' U2 M U M U M U2 or similar to solve. Also see the 'extra' bit below.

Corners

I solve the corners the same as on the old pochmann method. This is done with 2 cycles with the algorithm: R U' R' U' R U R' F' R U R' U' R' F R which shoots from buffer LBU to DFR having the side effect of switching edge UB and UL back and forth. You basically setup the corner to solved on DRF, do the algorithm and undo the setup moves. For instance: FR' R U' R' U' R U R' F' R U R' U' R' F R RF' to solve the FLU position. For extra things for this see the 'extra' part below.

Solving/Memorizing

I won't explain a technique to remember information but here's the way you make your path while memorizing. I first memorize the edges, you look at the FD cubie and see and memorize where that has to go, then you look and memorize where that one has to go, then where that one has to go until you are back on the FD or DF position again. This means you 'ended a cycle' if you notice you didn't came across every edge that is not solved yet that means that there are non-solved edges left. To continue shoot to any edge that is not solve (preferably one that has to go to BU because of the easy solving of that) and continue to look where that one has to go until you come across the position of the edge that you just randomly picked. You memorize the edges in pairs. It's easy to notice whether the centres are good or wrong this way: if an edge is the first of a pair the centres are good and there's nothing special, if the edge you are solving is the last of a pair AND it is the UF/FU BD/DB then you know you have to shoot to the opposite position at that moment. After you did this and you notice that you have an ODD number of edges you have something that's called a parity, we come to that after the corners. I store the edges in my long-term memory. Then it's on to the corners I store them in my short term memory so after I've done a solve I mostly don't remember the corners any more. You can memorize the corners in the same way as the edges if you like and can use pairs, but that's not nessesary. After memorizing the cube I solve the corners. If you have noticed an odd number of edges you also have an odd number of corners which results in a position where all corners are solved but the UB and UL edges are switched. What I do in that case is perform my PARITY algorithm: U'F2U M2 U'F2U this fixes the parity and has as side effect that it switches the centres already so you start with the centres wrong instead, so now if the FIRST of a pair of the edges is UF/FU BD/DB you have to shoot to it's opposite instead of the last.
Memorizing/solving should be about 50/50 of the time you use.

Extra's

Extra things, extensions, improvements etc.
Edge Extras:

As mentioned you are sometimes left with 2 or even 4(though this is very very rare) edges, you can use M' U M' U M' U2 M U M U M U2 (flips UB and UF) or R'U2R2UR'U'R'U2LFRF'L' (flips UF and UR). To speed up the edges you can sometimes solve 2 edges at once. This is done by making a 3 cycle of edges between Buffer-1st target-second target. This is especially handy if you have to shoot to one of the 3 'nasty' M edges. For instance to shoot to UB and then to UF is quite ugly but with: UM' M2UMU2M'UM2 MU' it's suddenly very nice. (note M2UMU2M'UM2 is an edge 3 cycle but you can use anything for that of course).
This whole idea leads to 2 other methods of solving always 2 edges at once:
the idea of the first method is to get the 2 next targets and the buffer in the same face, do an edge 3 cycle and then undo your setup moves again. This requires a bit more setup moves than normal 'old' pochmann but is quite effective.
the idea of the second method is to always solve the 2 next targets with a commutator and by this get rid of the setup moves. This however requires quite some knowledge about commutators and takes practise. Example: L'U2L E L'U2L E' which solves: buffer-FR-LB. Another example: M'UM D' MU'M' D which solves: buffer-FD-RD.

Corner Extras:
One idea is to use the R2 method Stefan uses although I think it is not nearly as nice as M2 because of the higher ratio of bad/good cases.
Another idea is to use all commutators like on the edges.
Another idea which was invented by me is to learn 2 more algorithms beside the: R U' R' U' R U R' F' R U R' U' R' F R which shoots to DFR but also the algorithms: R U R' F2 L D' L D L2 F2 which shoots to FRD and: F' U F R' D' F L F L' F2 D R which shoots to RDF.
The result of this is that you never require more than one setup move. For instance the setup for UFL=F2, FLU=F2, LUF=also F2. For shooting to any UFR sticker you can use even 2 moves: F or R' as setup.
I adapted the M2 method for my r2 method (note: not R2 but r2) for solving edges on a 4x4, see the links.

Links

Links closely related to what I use:
M2 method by the inventor himself, Stefan Pochmann, also thanks to him.
Joel's explanation of the 'old' Pochmann method and also some other interesting idea's.
Pochmann's first method

My 4x4 BLD solution with also my r2 method which is basically the same as M2 with some differences.

Things I didn't say

A lot of things, first of all a big thanks for Stefan!
You can use M2 method for any size cube to solve the edges, for 5x5 I'll use a combination of r2 and M2 to solve the edges on that.
There are numerous other ways of solving the cube blindfolded, this is just how I do it.