[Question]
  [
Write a program (or function) (let's call it P1), that when run, outputs another program P2 of the same language and exactly 1 byte longer than P1.
Program P2 when run, should output a 3rd program P3 that's 1 byte longer than P2. P3 must output a program P4 that's one byte longer than P3, etc. The same for P5, P6, ..., P∞.
The program chain should go indefinitely, or to a place where the interpreter can't handle anymore (but must remain as a theoretically valid program in the language)
# Rules
* Standard loopholes forbidden
* All programs in the chain should be in one language
* No input is given. Output goes to stdout or function return value
* The program must end after a period of time. A program that stops generating output after a certain time spot but never terminates does not qualify
The shortest program P1 in bytes in each language wins!
  
[Answer]
# JavaScript (ES6), ~~14~~ 12 bytes
-2 bytes thanks to @Shaggy
```
f=_=>"f=_"+f
```
## Testing snippet
```
s=`f=_=>"f=_"+f`;
for(i=10;i--;s=eval(s)())
  o.innerText+=s+"\n";
```
```
<pre id=o></pre>
```
[Answer]
# [7](https://esolangs.org/wiki/7), 4 bytes of ASCII
```
1603
```
[Try it online!](https://tio.run/##M///39DMwPj/fwA "7 – Try It Online")
I know that 7 isn't normally encoded in ASCII, but this time it's a more convenient encoding so that we're adding 1 byte with each run, not 3 bits.
I'm also not sure whether this counts as cheating or not. (It's usual to be unclear whether or not a 7 quine is cheating, as it straddles the borderline in a number of ways.) You can make a decent argument that the `0` encodes the `6`, but in general it's unclear where the resulting characters "come from" in 7 because it has so many, fairly bizarre, implicit behaviours.
This program prints itself with `1` appended, and will do so even if you append a number of `1`s to it. Here's a commented debug trace of `160311`:
```
|| 160311      Initial data ||; initial program 160311
||7 60311      1 command = append 7 to data
|1 0311        6 command = escape from the last | onwards (7 escapes to 1)
|16e77         0311 commands = append 6e77 to data
|16e77 16e77   Implicit (program is empty): copy data past last | to program
|16e777 6e77   1 command = append 7 to data
71603111 e77   6 command = escape from the last | onwards
71603111 e77   e7 command = output in same encoding as the source
```
(There are no `|` left in the program, so `e` will immediately quit the program as a side effect, meaning that the final `7`s never run).
The basic confusion about where all the characters are coming from is that most commands in 7 just produce data when run, and then `6` attempts to reconstruct a sequence of commands that would produce the given fragment of data; this often ends up close to, but not identical to, the original. (For quining purposes, you normally write a 7 program in such a way that the result will be almost the same, normally differing in leading or trailing `7`s.) So for example, the `1` in the data becomes `716`, which is the easiest way to append `1` to the current data string. We originally produced it with `16`, a different (but similar) character sequence, destructively removing one of the `|` markers the data started with. (I guess perhaps the best argument that this isn't a literal-only quine is that the output is different from the input!)
[Answer]
# [Haskell](https://www.haskell.org/), ~~74~~ 66 bytes
EDIT:
* -2 bytes by H.PWiz by using `<>`, then -6 by moving the `(10*)<$>`.
This now uses the newly free `<>` operator (`Semigroup` multiplication, requires GHC 8.4 to work without an import.)
```
main=putStr$fst<>show$(10*)<$>("main=putStr$fst<>show$(10*)<$>",1)
```
[Try it online!](https://tio.run/##y0gszk7NyfmfmVuQX1Si4JJYkqgXnJqbmV6UX1qgoWFjp6n5PzcxM8@2oLQkuKRIJa24xMauOCO/XEXD0EBL00bFTkMJv7ySjqHm//8A "Haskell – Try It Online") (Cheats with an import since TIO doesn't have GHC 8.4 yet.)
# How it works
* `main=putStr$` is boilerplate to output the following string value.
* `fst<>show` is a function that takes a tuple, and returns a string consisting of the first element of the tuple concatenated with the tuple's string representation. I.e.
```
(fst<>show)(s,t) = fst(s,t)<>show(s,t) = s++show(s,t)
```
* `(10*)<$>` multiplies the *last* element of the following tuple by 10, adding a digit `0` to its string representation.
[Answer]
# [C (gcc)](https://gcc.gnu.org/), ~~134~~ 132 bytes
Slight reworking of the canonical C quine. Dreadfully long.
```
x;*s="x;*s=%c%s%c;main(i){for(i=__LINE__;i--;puts(&x));printf(s,34,s,34);}";main(i){for(i=__LINE__;i--;puts(&x));printf(s,34,s,34);}
```
[Try it online!](https://tio.run/##S9ZNT07@/7/CWqvYVglMqiarFqsmW@cmZuZpZGpWp@UXaWTaxsf7ePq5xsdbZ@rqWheUlhRrqFVoaloXFGXmlaRpFOsYm@iACE3rWiWydf7/DwA "C (gcc) – Try It Online")
[Answer]
## [Fission 2](https://github.com/C0deH4cker/Fission), 7 bytes
```
'!+OR!"
```
[Try it online!](https://tio.run/##S8ssLs7MzzP6/19dUds/SFHp/38A "Fission 2 – Try It Online")
[The standard Fission quine](https://codegolf.stackexchange.com/a/50968/8478), but with an extra `!` that prints an additional 0x01 at the beginning of the code on each iteration.
[Answer]
# [Pari/GP](http://pari.math.u-bordeaux.fr/), 35 bytes
```
(f=(x)->print1("(f="f")("1x")"))(1)
```
[Try it online!](https://tio.run/##K0gsytRNL/j/XyPNVqNCU9euoCgzr8RQQwnIV0pT0tRQMqxQ0lTS1NQw1Pz/HwA "Pari/GP – Try It Online")
[Answer]
# [Python 2](https://docs.python.org/2/), 38 bytes
```
s="print's=%r;exec s'%(s+'#')";exec s
```
[Try it online!](https://tio.run/##K6gsycjPM/r/v9hWqaAoM69EvdhWtcg6tSI1WaFYXVWjWFtdWV1TCSrA9f8/AA "Python 2 – Try It Online")
[Answer]
# [brainfuck](https://github.com/TryItOnline/brainfuck), 420 bytes
```
->+++>>+++>+>++>+++>+>+>+++>>>>>>>>>>>>>>>>>>>>+>+>++>+++>++>>+++>+>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>+>+>>+++>>+++>>>>>+++>+>>>>>>>>>++>+++>+++>+>>+++>+++>+>++>>+++>+>+++>+>++>+++>>>+>+>++>+++>+>+>>+++>>>>>>>+>+>>>+>+>++>+++>+++>+>>+++>>>+++>+>++>+++>++>>+>+>++>+++>+>+>>+++>>>>>+++>+>>>>>++>+++>+++>+>>+++>>>+++>+>+++>+>>+++>>+++>>++[[>>+[>]++>++[<]<-]>+[>]<+<+++[<]<+]>>->[>]++++>++[[<++++++++++++++++>-]<+++++++++.<]>.
```
[Try it online!](https://tio.run/##hU9BCsNACHzQsHmBzEfEQ1oolEAOhbx/m7qtWROSuiA6O47j7TU@58dyn2otBEBP68OvaOgxelaM/QvnxBpH0lwIBjHsRNUtzi7YyX5XZZcdI1@Jc6HN35XM7i5Adc1K8wEVk2LeCwQNgJGFTmkk/fykYLENG8Q41PoG "brainfuck – Try It Online")
This is a modification on the "standard" [BrainFuck quine](https://github.com/jaburns/brainfuckToC/blob/master/quine.b), with a `.` at the end that tacks on an extra `.` each iteration.
The quine itself encodes Brainfuck characters as a stack of hex digits: specifically, the hex digits of `c-0x2b`, which conveniently are the following:
```
+: 0x00
-: 0x02
[: 0x30
]: 0x32
<: 0x11
>: 0x13
,: 0x01
.: 0x03
```
The encoding covers two snippets of code: `>++[[>>+[>]++>++[<]<-]>+[>]<+<+++[<]<+]>>->[>]++++>++` pushes the encoding of the encoding itself, and `[[<++++++++++++++++>-]<+++++++++.<]` walks the stack and prints everything.
[Answer]
# [Dirty](https://github.com/Ourous/dirty), 9 bytes
```
'"n[!]a!␛
```
[Try it online!](https://tio.run/##S8ksKqn8/19dKS9aMTZR8dGE2f//AwA "Dirty – Try It Online")
```
'   start and end a string literal
"   push a literal '
n   remove newlines
[!] print the string
a   push the alphabet
!   print the first character
␛   end the program
```
**If source-code reading is allowed:**
# [Dirty](https://github.com/Ourous/dirty), 8 bytes
```
Q[!]W33!
```
[Try it online!](https://tio.run/##S8ksKqn8/z8wWjE23NhY8f9/AA "Dirty – Try It Online")
**Explained:**
```
Q   push the source code
[!] print each character
W   clear the now-empty stack
33! print an exclaimation mark
```
**Might be valid:**
# [Dirty](https://github.com/Ourous/dirty), 4 bytes
```
Q[‼]
```
[Try it online!](https://tio.run/##S8ksKqn8/z8w@lHDntj//wE "Dirty – Try It Online")
It prints the source code with a trailing newline.  
(And a bunch of spaces, due to a bug. It works the same without them though.)
Note that it only works in the native character set, and not when you use the UTF8 front-end - so to try it on TIO you need to replace the character it outputs between the `[]`s with `‼`, which is the UTF8 equivalent for what it's printing.
[Answer]
# [GolfScript](http://www.golfscript.com/golfscript/), 9 bytes
```
{'.~1'}.~
```
[Try it online!](https://tio.run/##S8/PSStOLsosKPn/v1pdr85QvVav7v9/AA "GolfScript – Try It Online")
# [CJam](https://sourceforge.net/p/cjam), 9 bytes
```
{"_~1"}_~
```
[Try it online!](https://tio.run/##S85KzP3/v1opvs5QqTa@7v9/AA "CJam – Try It Online")
I'm posting both of these solutions in the same answer, since they're just trivial variations of each other and work in exactly the same way. They're both based on the common GolfScript quine `{'.~'}.~` (or `{"_~"}_~` in CJam), which is described in more detail e.g. in [this previous answer of mine.](https://codegolf.stackexchange.com/questions/21831/program-that-creates-larger-versions-of-itself-quine-variant/21876#21876)
The only difference is that this variant appends a `1` byte to the end of its output. As it happens, any string of `1`s (or any other integer literal without leading zeros) is itself a trivial quine in both GolfScript and CJam, so any ones already present at the end of the code above will simply be copied verbatim to the output. Since GolfScript (and CJam) use arbitrary-length integers, this will work for arbitrarily long programs, at least as long as the computer running the code has enough memory to store it.
[Answer]
# Java 8, ~~162~~ 146 bytes
```
v->{String s="v->{String s=%c%s%1$c+1;return s.format(s,34,s).replaceAll(%1$c1+$%1$c,%1$c%1$c);}"+1;return s.format(s,34,s).replaceAll("1+$","");}
```
[Try it online.](https://tio.run/##jU9Ni8IwEL37K4ZgIcEaKHorLuwP0Iuwl8VDjFFS07RkpoVF@tu7E@xlbwvzwcy8x7zXmNFsu97F5vacbTCIcDQ@vlYAPpJLd2MdnPIIcKbk4wOs/Or8DUZV83bi5EAy5C2cIMIB5nH78VrAeBB/psIWWFRru6nq5GhIEVDfu9Qaklju9iUqnVwf@OtnCDIjq806tzKXnKqexP/YgqmiFIIZc/3W2Q/XwDoXuWP20bJd@db3fTFqsfqD5FrdDaR7vpCM2so4hKAW19P8Cw)  
[Try the first output program](https://tio.run/##jU9Ni8IwEL37K4ZgIcEaKHorLuwP0Iuwl8VDjFFS07RkpoVF@tu7E@xlbwvzwcy8x7zXmNFsu97F5vacbTCIcDQ@vlYAPpJLd2MdnPIIcKbk4wOs/Or8DUZV83bi5EAy5C2cIMIB5nH78VrAeBB/psIWWFRru6nq5GhIEVDfu9Qaklju9iUqnVwf@OtnCDIjq806tzKXnKqeKvE/umCuKIVgyly/hfbDNbDQRe@YjbTsV74Ffl@MWrz@ILlWdwPpni8ko7YyDiGoxfY0/wI); [Try the second output program](https://tio.run/##jU9Na8MwDL3vVwjTgE1Tg9luoYP9gPZS2KXs4LnucOs4wVICo@S3pzLNpbeCPpD0HnrvYke76XqfLqfr7KJFhJ0N6fYGEBL5fLbOw76MAAfKIf2Bk99dOMGoGt5OnBxIloKDPSTYwjxuPm8LGLfiaapchZVZubVpsqchJ0B97nJrSWL9/lGj0tn3kb9@xSgL0qxXpdWllFTNZIx4jS@YLGohmDM3D6X98BtZ6SJ4LE5aNiwfCo8/Vi1m/5F8q7uBdM8Xkkk7mYYY1eJ7mu8); [Try the third output program](https://tio.run/##jU9Na8MwDL3vVwjTgE1Tg9luoYP9gPZS2KXs4LnucOs4wVICo@S3pzLNpbeCPpD0JL13saPddL1Pl9N1dtEiws6GdHsDCIl8PlvnYV9KgAPlkP7Aye8unGBUDXcndjYkS8HBHhJsYR43n7cFjFvxVFWuwsqs3No02dOQE6A@d7m1JLF@/6hR6ez7yF@/YpQFadarkuoSiqtmMsaI1w4I3ha1ELw0Nw@q/fAbmerCeCxSWlYsHxSPP1Ytav@RfKu7gXTPE5JJO5mGGNUifJrv).
**Explanation:**
```
v->{                       // Method with empty unused parameter and String return-type
  String s="v->{String s=%c%s%1$c+1;return s.format(s,34,s).replaceAll(%1$c1+$%1$c,%1$c%1$c);}"
                           //  The unformatted source code
           +1;             //  Plus a random digit (1 in this case)
  return s.format(s,34,s)  //  Create the quine
          .replaceAll("1+$","");}
                           //  Then remove any trailing 1s
```
[quine](/questions/tagged/quine "show questions tagged 'quine'")-part:
* The `String s` contains the unformatted source code.
* `%s` is used to input this String into itself with the `s.format(...)`.
* `%c`, `%1$c` and the `34` are used to format the double-quotes.
* `s.format(s,34,s)` puts it all together
Challenge part:
* `+1` adds a 1 to both the unformatted and formatted program.
* `.replaceAll("1+$","");}`: Because we only want to increase the program byte-count by one instead of two, we remove any trailing 1s before returning.
[Answer]
# [Jstx](https://github.com/Quantum64/Jstx), 4 [bytes](https://quantum64.github.io/Jstx/codepage)
```
£↕♣:
```
[Try it online!](https://quantum64.github.io/Jstx/JstxGWT-1.0.2/JstxGWT.html?code=wqPihpXimaM6)
[Answer]
# [><>](https://esolangs.org/wiki/Fish), 9 bytes
```
#o<:}-1:"
```
[Try it online!](https://tio.run/##S8sszvj/XznfxqpW19BK6f9/AA "><> – Try It Online")
Variation on a classic ><> quine, which simply adds another dupe command to copy the `#` in the front.
[Answer]
## [Perl 5](https://www.perl.org/), 32 bytes
```
$_=q{say"\$_=q{$_
};eval"};eval
```
[Try it online!](https://tio.run/##K0gtyjH9/18l3rawujixUikGzFKJ56q1Ti1LzFGCUFz////LLyjJzM8r/q/ra6pnYGgAAA "Perl 5 – Try It Online")
[Answer]
# [Attache](https://github.com/ConorOBrien-Foxx/attache), ~~76~~ ~~72~~ 61 bytes
```
Print!Format[x:="Print!Format[x:=%s,Repr[x+sp]]",Repr[x+sp]]
```
[Try it online!](https://tio.run/##SywpSUzOSP3/P6AoM69E0S2/KDexJLrCylYJXUC1WCcotaAoukK7uCA2VgmZw/X/PwA "Attache – Try It Online")
Standard quine which adds a space to the end of `x` after each iteration.
First few iterations:
```
Print!Format[x:="Print!Format[x:=%s,Repr[x+sp]]",Repr[x+sp]]
```
```
Print!Format[x:="Print!Format[x:=%s,Repr[x+sp]] ",Repr[x+sp]]
```
```
Print!Format[x:="Print!Format[x:=%s,Repr[x+sp]]  ",Repr[x+sp]]
```
etc.
### Attache, 72 bytes
```
y:=1Print!Format[x:="y:=%sPrint!Format[x:=%s,y*10,Repr!x]",y*10,Repr!x]
```
[Try it online!](https://tio.run/##SywpSUzOSP3/v9LK1jCgKDOvRNEtvyg3sSS6wspWCSioWowuqlqsU6llaKATlFpQpFgRq4TC4/r/HwA "Attache – Try It Online")
This is simply a variation of the standard format quine, with a variable `y` that is set to `10*y` after each iteration
The first few iterations:
```
y:=1Print!Format[x:="y:=%sPrint!Format[x:=%s,y*10,Repr!x]",y*10,Repr!x]
```
```
y:=10Print!Format[x:="y:=%sPrint!Format[x:=%s,y*10,Repr!x]",y*10,Repr!x]
```
```
y:=100Print!Format[x:="y:=%sPrint!Format[x:=%s,y*10,Repr!x]",y*10,Repr!x]
```
etc.
[Answer]
# [Runic Enchantments](https://github.com/Draco18s/RunicEnchantments/tree/Console), 6 bytes
```
"'<S@>
```
[Try it online!](https://tio.run/##KyrNy0z@/19J3SbYwe7/fwA "Runic Enchantments – Try It Online")
> 
> This one was weird. All I had to do was remove a `~` from the original quine [found by Jo King](https://codegolf.stackexchange.com/a/172877/47990).
> 
> 
> Every additional run appends another `<` to the end, e.g.:
> 
> 
> 
> ```
> "'<S@><<<<<<<<<
> 
> ```
> 
> All of which do nothing.
> 
> 
> 
Direct copy of [this answer](https://codegolf.stackexchange.com/a/179913/47990) on a related challenge. It just so happened to already grow by 1 byte every iteration (strong argument for this challenge being a duplicate of that one or vice versa).
[Answer]
# [Swift 4](https://developer.apple.com/swift/), 89 bytes
```
let(a,b)=(";print(\"let(a,b)=\\((a,b+\"-\"))\"+a)", "");print("let(a,b)=\((a,b+"-"))"+a)
```
Includes a trailing newline
[Try it online!](https://tio.run/##Ky7PTCsx@f8/J7VEI1EnSdNWQ8m6oCgzr0QjRgkuFhOjAWJoxyjpxihpasYoaSdqKukoKClpQtUiKYWoVNIFqgMp4/r/HwA "Swift 4 – Try It Online")
[Answer]
# [Haskell](https://www.haskell.org/), 88 bytes
```
main=putStr$snd(span(<'m')s)++show s;s='#':"main=putStr$snd(span(<'m')s)++show s;s='#':"
```
[Try it online!](https://tio.run/##y0gszk7Nyfn/PzcxM8@2oLQkuKRIpTgvRaO4IDFPw0Y9V12zWFNbuzgjv1yh2LrYVl1Z3UqJFLX//wMA "Haskell – Try It Online") Grows by prepending `#` to the data string.
[Answer]
# [Wonder](https://github.com/wonderlang/wonder), 33 bytes
```
f\ @(-> ol) ["f\ ";f;";f1";#0];f1
```
An interesting variant on the normal quine that appends a 1 after each iteration.
Progression:
```
f\ @(-> ol) ["f\ ";f;";f1";#0];f1
f\ @(-> ol) ["f\ ";f;";f1";#0];f11
f\ @(-> ol) ["f\ ";f;";f1";#0];f111
...
```
# Explanation
```
f\ @                               #. Sets f to a function that does the following:
    (-> ol) [                      #.   Output each:
             "f\ ";                #.     String for declaration of f
                   f;              #.     Formatted representation of f's function
                     ";f1";        #.     String for call of f
                           #0      #.     Argument passed into f
                             ];f1  #. Call f with 1 as the argument
```
One of the interesting parts of this quine is that Wonder can work with numbers of arbitrary precision, so the progression won't break after a certain amount of ones.
[Answer]
# [Stax](https://github.com/tomtheisen/stax), ~~20~~ 18 bytes
```
"34s+cTZL"34s+cTZL
```
[Run and debug it](https://staxlang.xyz/#c=%2234s%2BcTZL%2234s%2BcTZL&a=1)
Generates an extra space before the 2nd quotation mark every iteration.
## Explanation
Uses the program `"34s+cTZL "34s+cTZL` to explain.
```
"34s+cTZL "34s+cTZL
"34s+cTZL "            String literal
           34s+        Prepend a double quote, Now the string is `"34s+cTZL `
               cT      Copy and trim trailing spaces
                 Z     Put a 0 under the top of stack
                       Stack now (from top to bottom): `["34s+cTZL,0,"34s+cTZL ]`
                  L    Collect all elements on stack, from bottom to top
                       Implicit output, 0 is converted to space.
```
[Answer]
# [Gol><>](https://github.com/Sp3000/Golfish), 7 bytes
```
":r2ssH
```
[Try it online!](https://tio.run/##S8/PScsszvj/X8mqyKi42OP/fwA "Gol><> – Try It Online") [Try it online!!](https://tio.run/##S8/PScsszvj/X8mqyKi42MPj/38A "Gol><> – Try It Online") [Try it online!!!](https://tio.run/##S8/PScsszvj/X8mqyKi42MPD4/9/AA "Gol><> – Try It Online")
This is a simple variation of the regular [Gol><> quine](https://codegolf.stackexchange.com/a/160994/78410) but adds a copy of `H` each time it's run. Since the `H` command halts the program, additional `H` at the end does not change the behavior.
[Answer]
# [C# (Visual C# Interactive Compiler)](http://www.mono-project.com/docs/about-mono/releases/5.0.0/#csc), 89 bytes
```
var s="var s={0}{1}{0}+8;Write(s.Trim('8'),(char)34,s);"+8;Write(s.Trim('8'),(char)34,s);
```
Inspired by Kevin Cruijssen's answer.
[Try it online!](https://tio.run/##Sy7WTS7O/P@/LLFIodhWCUJVG9RWG9YCSW0L6/CizJJUjWK9kKLMXA11C3VNHY3kjMQiTWMTnWJNayWCKv7/BwA "C# (Visual C# Interactive Compiler) – Try It Online")
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), 11 bytes
```
“⁾;⁶;ØV” ṘV
```
[Try it online!](https://tio.run/##AR8A4P9qZWxsef//4oCc4oG@O@KBtjvDmFbigJ0g4bmYVv// "Jelly – Try It Online")
[Answer]
## ColdFusion, 277 bytes
```
<cfset u=Chr(34)><cfset q="<cfset u=Chr(34)><cfset q=%s%s%s><cfoutput>%screateObject(%sjava%s,%sjava.lang.String%s).format(q,[u,q,u,Chr(35),u,u,u,u,Chr(35)])%s</cfoutput>
"><cfoutput>#createObject("java","java.lang.String").format(q,[u,q,u,Chr(35),u,u,u,u,Chr(35)])#</cfoutput>
```
This is a trivial modification of [my ColdFusion quine](https://codegolf.stackexchange.com/a/159608/9365) which adds a newline each extra time it's called.
Tested locally on lucee-express-5.2.6.60
[Answer]
## Windows Batch, ~~38~~ 36 bytes
```
echo|set/p"=q">q&copy/b/y %0+q %0
::
```
This code creates a file called "q", containing the letter 'q', and then appends it to the original file.
Note that "::" is an alias for "rem" that does not require an additional space.
Saved 2 bytes thanks to user3493001.
[Answer]
# [T-SQL](https://www.microsoft.com/sql-server), 175 bytes
```
DECLARE @ VARCHAR(MAX)='DECLARE @ VARCHAR(MAX)=*SET @=TRIM(REPLACE(@,0x2a,CHAR(39)+@+CHAR(32)+CHAR(39)))PRINT @'SET @=TRIM(REPLACE(@,0x2a,CHAR(39)+@+CHAR(32)+CHAR(39)))PRINT @
```
First I wrote an SQL quine, then I modified it to add an extra space (somewhat inspired by [this answer](https://codegolf.stackexchange.com/a/159477/78876)).
[Answer]
# [Befunge-98 (PyFunge)](https://pythonhosted.org/PyFunge/), ~~22~~ 19 bytes
```
r:#,_ #;'D2/'<,,@;"
```
[Try it online!](https://tio.run/##S0pNK81LT9W1tNAtqAQz//8vslLWiVdQtlZ3MdJXt9HRcbBW@v8fAA "Befunge-98 (PyFunge) – Try It Online")
Adds a < before the last " every generation.
[Answer]
## [Jstx](https://github.com/Quantum64/Jstx), 4 bytes
```
£↕☺V
```
[Try it online!](https://quantum64.github.io/Jstx/JstxGWT-1.0.2/JstxGWT.html?code=wqPihpXimLpW)
## Explanation
Verbose code:
```
meta.source    Push the source
load 1         Push 1
string.concat  Concatenate source with 1
               Implicit output
```
[Answer]
# [C (gcc)](https://gcc.gnu.org/), 71 bytes
```
#define a(b)*s=#b;b
a(main(){printf("#define a(b)*s=#b;b\na(%s;)",s);})
```
Every iteration adds a semicolon after the closing brace of the main function.
[Try it online!](https://tio.run/##S9ZNT07@/185JTUtMy9VIVEjSVOr2FY5yTqJK1EjNzEzT0OzuqAoM68kTUMJi6KYvEQN1WJrTSWdYk3rWs3///8lp@Ukphf/1y0HAA "C (gcc) – Try It Online")
]