Your desire for such an algorithm cannot be satisfied. As randomtoad said, it will require more moves than the best odd parity algorithms that exist already. Your best bet is to just do double layer turns with one of the pure algorithms (like everyone already does).

The ideal algorithm, which you are interested in, can be derived from an pure “edge flip” algorithm in which its ending moves are only outer-layer turns, there by making it possible to omit those last moves so that you are not doing worthless 3X3X3 restoration (as long as those moves restore only the last layer and maybe one F2L slot, as you have requested).

There is no "dedge flip" algorithm that exists (which is shorter in length than the pure edge flip algorithms) that satisfies this constraint, nor will there ever be.

Proof:

There are two main reasons for this:

[1] "Edge flip" algorithms', or even just every pure odd parity algorithm’s, main goal is to preserve the centers: if they don’t preserve the centers, then you might as well use the Cage Method (which as you know is not going to give you a world record: commutators are an inefficient way to solve the centers).

[2] The wing edges need to be separated in the beginning of the algorithm and subsequently at the **end** of the algorithm (which is **slice** turns, not outer-layer turns).

Unlike all other forms of odd parity restricted to the LL, the "one edge flip" is the case which requires the most moves (or at least it is safe to say that, no other form of odd parity will actually require more than the least moves that the one-edge flip can be done in) because the two wing edges are initially in the same composite edge.

The "r2 B2" and "B2 r2" that you see at the beginning and end of common algorithms is to bring the initially front-right wing edge to the back-left, so that the front-left and back-left are directly across from each other (or vice versa, depending on which mirror you do). (Note: there are other ways to move two winged edges besides r2 B2/l2 B2, which are originally in the same composite edge, opposite to one another, in 4 block quarter turn moves, but this is the only way to get them across from each other in 2 block half turn moves).

For example, the best opposite winged edge swap from my understanding (or its mirror) is:

l' U2 l' U2 F2 l' F2 r U2 r' U2 l2

Now, to make this a pure edge flip, it is going to cost us some more moves. We start off with adding "l2 B2" to the beginning and "B2 l2" to the end.

l2 B2

l' U2 l' U2 F2 l' F2 r U2 r' U2 l2

B2 l2

But, we have a problem: the top and bottom centers are discolored slightly.

To fix this problem, all you need to do is add 1 half turn slice in the beginning and the end:

l2 B2 **l2**

l' U2 l' U2 F2 l' F2 r U2 r' U2 l2

**l2** B2 l2

As you probably can see, there are three block quarter turn moves which disappear due to move cancellations, and we are left with a 25 block quarter turn alg/15 block half turn alg:

l2 B2 l U2 l' U2 F2 l' F2 r U2 r' U2 B2 l2

Just as the "base" for the alg above was l' U2 l' U2 F2 l' F2 r U2 r' U2 l2, if you try, you will find that the base of r2 B2 U2 l U2 r' U2 r U2 F2 r F2 l' B2 r2 is:

r2 B2 r2

**r2 U2 l U2 r' U2 r U2 F2 r F2 l' r2**

r2 B2 r2

With all of that said, I just wanted to show you that you must first separate the dedge pieces (some how) in order to swap them.

As you have seen in the two previous examples, **if you separate wing edges at the beginning of an alg, then you’re going to have to reverse it at the end.** You are not going to be able to do the reverse of the slice turns so that all which remains after it are outer layer turns (well, unless you add in a lot of outer layer turns at the end, then maybe you could do this—you can try it, but I will not waste my time).

In short, your fantasy algorithm does not exist. (Here I am assuming that you desire an algorithm which is shorter than a typical edge flip alg because I definitely can say that such an algorithm that you are requesting will definitely not be “prettier” than what you already have access to).

End of Proof

Just as there are rules in integration that cause an infinite number of integrals to not exist, so are there rules for the cube. But in Calculus, we have the alternative to integrate a function (whose anti-derivative cannot be expressed in terms of elementary functions) by expanding the function as an infinite power series and integrating it term-by-term. Similarly, this algorithm can be done by expanding (adding in a lot more outer-layer turns at the end or making the overall length of the algorithm longer), but it will not be pretty (if it can even be done at all). But whether talking about cubing or calculus, the alternative is not very beautiful.

As Lucas Garron mentioned, maybe what you are really hungry for is a pure edge flip algorithm that is the least number of moves. I am assuming he meant block quarter turn moves, because in block half turn moves, we already have the optimal algorithm (15).

For speedcubing purposes, these briefest pure “edge flip” algorithms (in block quarter turn moves) are most likely not going to be necessarily faster to perform than the current algorithms (I perform a few of mine around the same amount of time), even though they might be 5-6 block quarter turn moves less.

If you absolutely hate the “one edge flip”, then use K4 (as V-te said). To make sure you avoid it using that method, first do commutators to make all of the LL yellow. Then do 1 of the 2 possible odd parity algorithms (or their mirrors). Unfortunately, this process often makes the cuber to do more moves than necessary to complete the LL edges.

You might think that the pure "edge flip" algorithms stink, but if you knew how much they accomplish, even though they are bounded by a very large number of constraints (the shorter the algorithm, the more constraints the composer of the algorithm has to overcome), you would develop a hate for the odd number of slice turns you use to solve the centers at the beginning! The "parity errors" therefore can be renamed "human errors" because we do have control to prevent them (but of course for speedcubing, there is no way to detect it in during inspection time—unless you are amazing). Pure odd parity algorithms are our "spare tires", if you will, and there is no "spare tire" which we can put on our car faster than what we already have.