Note that this discussion generalizes to any NxNxN. The case
when N is even is actually slightly harder than when N is odd,
because it creates ambiguity in the correct orientation of the edges.
Note a fun bandaging of this puzzle here.
I'm going to use ML and MR to denote
any middle slice left of center, or right of center, respectively. For comparison, the left-most slice is L, and the right-most slice is R.
Similarly, I will use PD and PU to denote the equivilant idea with slices parallel to D and U, respectively.
I will use T to denote the entire middle slice parallel to F and B, but having the same orientation as F. Executing T means rotating 4 middle layers at the same time, not including F or B.
Lastly, the term "back tracking" is abused here a bit. By this, I don't mean that you have to undo a bunch of moves to get back to a certain state, then go down a different path. Rather, I mean that you have to go back to a previous step and start from there.
Put the centers together, not necessarily in their correct locations. This is very intuitive. The crux is at the final two faces. There is a trivial commutator you can find that tri-cycles centers while preserves corners, even though we don't need such preservation at this stage.
Here is an example: ML',U,MR,U',ML,U,MR',U'
There are obvious variations of this.
Note that the two middle slices involved here do not necessarily need to be the same distance from center.
Now put the edges together while preserving centers. Again, there is a trivial commutator you can find to do this that preserves the centers, and such preservation is obviously needed at this stage.
Here is an example: PD',X,PD,X'
Here, X is given by: (L',U',L),2U,(F,U',F')
Again, there are obvious variations of this.
Note that there is a much faster method of getting all the edges put together where center slices are temporarily scrambled (but always kept as 4 sets of 4 lines) while the first 8 edges are solved. The final 4 edges are then put together traditionally after quickly fixing the said scrambled centers. Details are left to the reader.
Lastly, it's important to understand that in this step you can always get all the edges put together, but the final edge might not have consistent orientation. Don't worry about this for now.
At this point, the cube looks like a 3x3x3, save that one of the edges, as said before, might not have consistent orientation. In any case, try to solve the cube as a 3x3x3. (My page for that is here.) Trying to do so, you'll encounter zero or more of two different problems: Either two composite edges will need to be swapped, or one composite edge (usually chosen as the one with inconsistent orientation, if it exists) needs to be flipped. This latter problem is equivilant to fixing the edge with possibly inconsistent orientation. Of course, if you don't encounter either of these problems, then the 3x3x3 solve finishes the puzzle.
This is trivial. Just use the edge tri-cycle found in Step 2 above, but adapt the algorithm to work with all middle slices above and below of center.
This is actually the most interesting part of the puzzle, in my opinion. Note that it looks like an orientation problem, but it's actually a positioning problem with regard to the edge pieces.
The problem is that a subset of the edge pieces can't be solved by tri-cycles, because two of them need to be swapped. The fix is actually trivial, but causes a significant amount of back-tracking in the solve. What you do is simply rotate a proper middle slice 90 degrees, and that fixes the problem, because it's an even permutation in a subgroup of the edges, at which point, they can now be solved by tri-cycles. This is where the preservation property of the tri-cycle found in Step 1 actually matters. A proper slice is any slice in the subgroup (or factor group) of unsolved edge pieces, but the best choice is a slice involving edge pieces already misplaced. This helps minimize the extent of the back-tracking.
All that said, some algorithms can help reduce the extent of the back-tracking even further. (There is a very lengthy algorithm someone has come up with for solving the parity problem altogether, but I can't remember it.) What I do is execute Y,2T,Y',2T,ML,|L|,Y', where Y=ML',2U,ML,2U. What this does is simply take the unsolvable tri-cycle state of the edge pieces and put them in a solvable state. Finish up with edge tri-cycling as usual, and you're done.
But we can do even better using Y,2T,Y',2T,ML,|2U|,2U,MR,2U,MR', at which point, only 2 tri-cycles are required to finish the solve, and they can be combined into a single, smaller sequence, such as PD',X,PD,PU,X',PU'.