A Program that Prints Programs
CJam, 4.56 × 10526 programs
2D#2b{"\256b_(256b:c'\s`_:(er`":T~{;38'ÿ*`{:T~{;63'ÿ*`{:T~{;88'ÿ*`{:T~{;114'ÿ*`{:T~{;140'ÿ*`{:T~{;166'ÿ*`{:T~{;192'ÿ*`{:T~{;219'ÿ*`{Q?\"_~"}s(\T}?\"_~"}s(\T`}?\"_~"}s(\T`}?\"_~"}s(\T`}?\"_~"}s(\T`}?\"_~"}s(\T`}?\"_~"}s(\T`}?\"_~"}s(\T`}?\"_~"}_~
Exact score: 254219 + 254192 + 254166 + 254140 + 254114 + 25488 + 25463 + 25438 + 25413 + 3
All programs have to be saved using the ISO-8859-1 encoding to comply with the file size limit.
Thanks to @ChrisDrost who pointed out a bug and suggested the nesting approach.
Try it online in the CJam interpreter.
254219 + 2 ≈ 4.56 × 10526 programs
The line share of the score can be achieved by the following, much simpler program1.
"ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ"
{\256b_(256b:c'\s`_:(er`Q?\"_~"}_~
Running this program produces the program
"ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿþ"
{\256b_(256b:c'\s`_:(er`Q?\"_~"}_~
and after 254219 - 1 more iterations, the program
{\256b_(256b:c'\s`_:(er`Q?\"_~"}_~
This last non-empty program exits with an error2 and prints nothing (the empty program).
How it works
Assume the string is already on the stack.
{ e# Push a code block.
\ e# Swap the string on top of the code block.
e# This will cause a runtime error if there is no string on the stack.
256b e# Convert the string (treated as a base-256 number) to integer (I).
_( e# Copy the integer and decrement the copy.
256b e# Convert the integer into the array of its base-256 digits.
:c e# Cast each base-256 digit to character. Converts from array to string.
'\s e# Push a string that contains a single backslash.
` e# Push its string representation, i.e., the array ['" '\ '\ '"].
_:( e# Push a copy and decrement each character. Pushes ['! '[ '[ '!].
er e# Perform transliteration to replace "s with !s and \s with [s.
e# This skips characters that require escaping.
` e# Push its string representation, i.e., surround it with double quotes.
Q e# Push an empty string.
? e# Select the first string if I is non-zero, the empty string otherwise.
\ e# Swap the selected string with the code block.
"_~" e# Push that string on the stack.
} e#
_~ e# Push a copy of the code block and execute it.
e# The stack now contains the modified string, the original code block
e# and the string "_~", producing an almost exact copy of the source.
254192 ≈ 5.35 × 10461 more programs
This is where things get a little crazy.
The first program is highly compressible. By writing a similar program that, instead of the empty program, eventually produces the first program from the above section, we can improve the score by 254192 programs3.
The program
"ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ"
{"\256b_(256b:c'\s`_:(er`":T~{;219'ÿ*`{Q?\"_~"}s(\T}?\"_~"}_~
is similar to the first program of the previous section, and running the former and its output for 254192 iterations produces the latter.
Assume the string is already on the stack:
{ e# Push a code block.
"\256b_(256b:c'\s`_:(er`" e# Push that string on the stack.
e# The characters inside it behave exactly as
e# they did in the previous section.
:T~ e# Save the string in T and evaluate it.
{ e# If the integer I is non-zero, keep the generated
e# string; else:
; e# Pop the code block from the stack.
219'ÿ*` e# Push a string of 219 ÿ's (with double quotes).
{Q?\"_~"} e# Push that block on the stack.
s e# Push its string representation.
(\ e# Shift out the { and swap it with the tail.
T e# Push T.
}? e#
\ e# Swap the selected string with the code block
e# or T with the tail of the code block.
"_~" e# Push that string on the stack.
} e#
_~ e# Push a copy of the code block and execute it.
Moar programs
The first program of the previous section is still highly compressible, so we can apply a similar method and write a program that, after 254166 iterations, produces the aforementioned program.
Repeating this technique over and over again until we hit the 255 byte limit, we can add a total of 254166 + 254140 + 254114 + 25488 + 25463 + 25438 + 25413 + 1 ≈ 1.59 × 10399 programs to those of the previous sections.
1 Newline added for clarity.
2 Per consensus on Meta, this is allowed by default.
3 or 0.0000000000000000000000000000000000000000000000000000000000000012 %
JavaScript, 1000 programs
x=999;
q=";alert(x=999?`q=${JSON.stringify(q)+q}`.split(x).join(x-1):``)";
alert(
x ? `x=999;q=${JSON.stringify(q)+q}`.split(x).join(x-1) // basically .replaceAll(x, x-1)
: ``
)
Whether this is valid depends on precisely how to understand the third rule.
Python 2, 9.7*10^229 programs
O=0
if len(hex(O))<191:print"O=0x%x"%(O+1)+open(__file__).read()[-68:]