Your job is to create the longest period iterating quine, where the length of each program in the sequence is bounded by 500 bytes.

That is, if you repeat the following steps:

1. Start with your initial program


2. Run the current program


3. Go back to step 2

You will eventually get back to your original program. The number of programs in the cycle is your score, which you are trying to maximize.

None of the programs may raise any errors. Each program must be run the same way as well (e.g. no different versions, implementations, compiler options, platforms, etc...).

What separates this challenge from The longest period iterating quine (other than 100 v.s. 500) is that every program in the cycle must also be 500 bytes or less. This means that the longest possible cycle is (256^501 - 1)/255 or less. That of course is a big number, but not that big in terms of how much code it takes to calculate. So the challenge is about using as many of the (256^501 - 1)/255 possibilities as you can, not a busy beaver challenge.

The programs are not permitted to access its own source code. However an empty program is permitted if you want (as long as you follow the other rules).

Since checking the programs manually would be hard, you may figure out the score using theoretical methods. You must include an explanation of the score and correctness with your program. If you can not figure out the score, you may instead use a lower bound of the number of programs in the cycle as a defacto score. You are allowed to update this as you find better lower bounds, or if you find the exact actual score.

This is code-challenge, so highest score wins!

Perl 6, $126^{398}$ iterations

$!=Q~~;<say "$!=Q~{chrs(my@a=[R,] polymod :126[$!.ords]+1: 126 xx*)x?(@a-399)}~;<$_>~~.EVAL">~~.EVAL

Try it online!

This iterates through all the possible combinations of the first 126 bytes of length 398 and under (excluding strings with leading NUL bytes). If you want to see that it actually returns to the first iteration, you can reduce the length to 1 by changing the limit like so.

Explanation:

Each iteration increments the string, stored in base 126 form, and then converts it back to base 126. It does this until it reaches a string with length 399, and then resets the string back to empty again. If you're having trouble conceptualising the number, imagine it with ten bytes instead. Starting from 0, increment up to 4 digits, 1000 and reset. This is $10^{4-1}$ iterations (including 0 or empty string in my program's case).

$!=Q~~;         # Start with an empty string

< ... >~~.EVAL  # Set a string to $_ and EVAL it

  say "$!=Q~{...}~;<$_>~~.EVAL"   # Print the program with the string replaced by

                       :126[$!.ords]   # The string converted from base 126

                                    +1 # Incremented

          [R,] polymod                : 126 xx*  # Back to base 126

chrs(                                )  # Back to a string

     my@a=                            x?(@a-399)  # Only if it isn't 399 characters

Gol><>, 67 bytes

":1=l8:*4+=S&Q~P:'~'=Q~~'H'||lPaa*5*=?1:1=Q$~|:1)lPaa*5*(Q?:|r2ssHH

Basically this program replicates the H at the end, then when it reaches 499 in length, appends a char with an ascii code of 1, this begins the deletion process, then when it reaches its original length plus one, it increments the last char. Finally, if the last char is a '~', it pushes an H instead!!!

I have no idea what the score would be... Too much math for tonight, I'll figure it out tomorrow...

Try it online!