Auto cycler quine

Question

Make a quine but with a twist.

Statement

The quine prints its code but puts its first character at the end.
(You can do it in reverse but include that note in your answer)
The output must then be a program which is also an solution.

Example: Assume your code was foobar, running it will return oobarf which will be another valid program.

foobar -> oobarf
oobarf -> obarfo
obarfo -> barfoo
barfoo -> arfoob
arfoob -> rfooba
rfooba -> foobar

Rules

• Your code must not be an output of some generation of someone else's code that's quite obviously stealing
• Your code must be more than 2 characters long (so short code is no fun)
• Your code must contain at least two different characters (ex: +++ is not valid)

Scoring

As a code-golf challenge the shortest code wins.

Answer 1

Befunge-98 (PyFunge), 2600 bytes

ab*1'3:*2+*0pnd3*:::::::::::::::1'3:*3+*0p1'3:*5+*0p1'3:*d+*0p1'3:*f+*0p1'3:*fa++*0p1'3:*fd++*0p1'4'3*f-*0p1'4'3*7-*0p1'4'3*5-*0p6:*:*4-1p6:*:*4+1p6:*:*8+1p6:*:*a+1p6:*:*8+2p6:*:*f1++2p6:*:*f3++2pn75*1-:1'3:*4+*0p6:*:*f2++2pnaa*:::::::::::::::::1'3:*6+*0p1'3:*7+*0p1'3:*f1++*0p1'3:*f2++*0p1'3:*fe++*0p1'3:*ff++*0p1'4'3*e-*0p1'4'3*d-*0p1'4'3*4-*0p1'4'3*3-*0p6:*:*3-1p6:*:*2-1p6:*:*b+1p6:*:*c+1p6:*:*9+2p6:*:*a+2p6:*:*f4++2p6:*:*f5++2pn67*::::::::::1'3:*8+*0p1'3:*a+*0p1'3:*f4++*0p1'3:*f5++*0p1'4'3*f-5-*0p1'4'3*c-*0p1'4'3*2-*0p6:*:*1-1p6:*:*d+1p6:*:*b+2p6:*:*f6++2pna5*::1'3:*9+*0p1'3:*f3++*0p6:*:*1pn68*:::::1'3:*b+*0p1'3:*f8++*0p1'4'3*f-2-*0p1'4'3*9-*0p1'4'3*1+*0p6:*:*f7++2pne8*:::::::1'3:*c+*0p1'3:*f9++*0p1'4'3*f-1-*0p1'4'3*8-*0p1'4'3*2+*0p6:*:*f2++1p6:*:*f+2p6:*:*f8++2pnf4*:1'3:*e+*0p1'4'3*3+*2pn77*::::1'3:*f6++*0p1'4'3*f-4-*0p6:*:*f1++1p6:*:*c+2p6:*:*e+2pnb4*1-::1'3:*f7++*0p6:*:*f+1p6:*:*d+2pnf4*1-::1'3:*fb++*0p6:*:*7+2p1'3:*1+*2pnf4*2-1'3:*fc++*0pn95*:::1'4'3*f-3-*0p1'4'3*a-*0p1'4'3**0p6:*:*1+1pn87*1'4'3*b-*0pnac*2-:1'4'3*6-*0p1'4'3*3+*0pnf4*3-1'4'3*1-*0pn88*2-6:*:*5-1pnc9*1-6:*:*2+1pnb4*:6:*:*3+1p6:*:*6+1pn88*6:*:*9+1pnd4*1-6:*:*e+1pnc8*2-:1'3:**1p1'3:**2pnd7*2+6:*:*4+2pn75*6:*:*6+2pn>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>ab*1'3:*2+*0pnd3*:::::::::::::::1'3:*3+*0p1'3:*5+*0p1'3:*d+*0p1'3:*f+*0p1'3:*fa++*0p1'3:*fd++*0p1'4'3*f-*0p1'4'3*7-*0p1'4'3*5-*0p6:*:*4-1p6:*:*4+1p6:*:*8+1p6:*:*a+1p6:*:*8+2p6:*:*f1++2p6:*:*f3++2pn75*1-:1'3:*4+*0p6:*:*f2++2pnaa*:::::::::::::::::1'3:*6+*0p1'3:*7+*0p1'3:*f1++*0p1'3:*f2++*0p1'3:*fe++*0p1'3:*ff++*0p1'4'3*e-*0p1'4'3*d-*0p1'4'3*4-*0p1'4'3*3-*0p6:*:*3-1p6:*:*2-1p6:*:*b+1p6:*:*c+1p6:*:*9+2p6:*:*a+2p6:*:*f4++2p6:*:*f5++2pn67*::::::::::1'3:*8+*0p1'3:*a+*0p1'3:*f4++*0p1'3:*f5++*0p1'4'3*f-5-*0p1'4'3*c-*0p1'4'3*2-*0p6:*:*1-1p6:*:*d+1p6:*:*b+2p6:*:*f6++2pna5*::1'3:*9+*0p1'3:*f3++*0p6:*:*1pn68*:::::1'3:*b+*0p1'3:*f8++*0p1'4'3*f-2-*0p1'4'3*9-*0p1'4'3*1+*0p6:*:*f7++2pne8*:::::::1'3:*c+*0p1'3:*f9++*0p1'4'3*f-1-*0p1'4'3*8-*0p1'4'3*2+*0p6:*:*f2++1p6:*:*f+2p6:*:*f8++2pnf4*:1'3:*e+*0p1'4'3*3+*2pn77*::::1'3:*f6++*0p1'4'3*f-4-*0p6:*:*f1++1p6:*:*c+2p6:*:*e+2pnb4*1-::1'3:*f7++*0p6:*:*f+1p6:*:*d+2pnf4*1-::1'3:*fb++*0p6:*:*7+2p1'3:*1+*2pnf4*2-1'3:*fc++*0pn95*:::1'4'3*f-3-*0p1'4'3*a-*0p1'4'3**0p6:*:*1+1pn87*1'4'3*b-*0pnac*2-:1'4'3*6-*0p1'4'3*3+*0pnf4*3-1'4'3*1-*0pn88*2-6:*:*5-1pnc9*1-6:*:*2+1pnb4*:6:*:*3+1p6:*:*6+1pn88*6:*:*9+1pnd4*1-6:*:*e+1pnc8*2-:1'3:**1p1'3:**2pnd7*2+6:*:*4+2pn75*6:*:*6+2pn>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>

Try it online!

This making this was a hellfest.

How this works:
The program is a bunch of put statements that assembles a Program B around itself which then prints half of the source byte shifted twice.
The program is actually 2 copies of a 1300 byte program, this is so it's ensured that the whole 1300 byte program always gets ran as a whole.

Better explanation:
Every Befunge-98 quine needs to contain symbols such a @ or q and ,
Problem: None of those symbols are a good starting point especialy since @ and q terminate the program instantly.
Solution: Get rid of those characters in the source code

Problem: How?
Solution: Use p (put) commands to modify the source code to include the required characters which will print the contains of the source code shifted by one byte and not use the g command which is cheating.

Problem: (sigh when will these end)
A put command pops 3 values n x y which determine character, x-coord, y-coord however when the initialization of these values is split in half it can write bad characters in the beginning source code making it useless for quining.
Solution: (last one I promise)
Use 2 copies of the source code, the latter one being the "correct one" this accidentally fixes another problem which is that a put statement (p command + the constant initializers) which is split in half will not get executed, this is fixed by having 2 copies of each statement. Last thing this needs to work is how do we make the whole source code out of a half?

Answer:

This is visual proof of why two copies of a string byte shifted == Two copies of a byte shifted string. That means we can take a half of the code, byte shift it, then print it twice (OR take half of the code, byte shift it, print, repeat [That's what actually happens])

How this is implemented: Assume 0123456789abcdef is the source

Befunge Pseudocode:

0123456789abcv;;"123456789abcdef" < go this way <--
             >PS'0,   repeat 2x   ^

PS means Print Stack (not a real instruction). We push half of the source code in reverse onto the stack using "" then we print the stack and then we fetch (' command) the first character 0 which we move in front of the ' and print it last which causes the byte shift, then we repeat the cycle once more to print the second copy. One technicality to deal with are the symbols inside the source, this can cause trouble if we write it while executing the source code, I circumvented this by adding more put statements which take care of it externally.

This makes the code look something like this:

Explanation:
Green Highlight: Code that takes care of adding characters into the source
Grey Letters (probs poor visibility sorry): Code that gets added by green code
Red Highlight: Code that moves first character of the second half of source code into the Blue area.
Blue Highlight: See Red Highlight
Orange Highlight: Code that makes sure we terminate after we wrote 2 byte shifted copies by putting a @ (terminate) command into the Yellow Area.

Arrows should hopefully make it clearer how the code flow goes.

Here comes the last tough part:
Where do babies source code come from?

Short answer: C# Magic
Long answer: 100+ Befunge code snippets made by hand compiled by C# code. I manually wrote about 100 constant initializers (a piece of befunge code that pushes a certain number to stack) by hand and then used a custom C# program to compile it into the 1300 byte Befunge output, which I then copy pasted twice and made the final program.

Are you still here? Great thank you for reading! (or at least scrolling to the end)
I hope my bad jokes were fun and not annoying.

Note: No put statement in this code creates a g command which would be cheating.

EDIT: I have verified the code using the following Javascript code in TIO using developer tools

setInterval(()=>{document.getElementById("code").value = 
document.getElementById("output").value; 
document.getElementById("run").click();}, 2000);