Write a Metaquine

Question

A metaquine is a program which is not a quine, but whose output, when run as a program in the same language, is a quine.

The goal of this challenge is to write a metaquine. This is code-golf, so shortest code wins, with earliest answer used as a tiebreaker. Note that only full programs are acceptable, due to the definition of a quine.

Rules for Quines

Only true quines are accepted. That is, you need to print the entire source code verbatim to STDOUT, without:

• reading your source code, directly or indirectly.
• relying on a REPL environment which just simply evaluates and prints every expression you feed it.
• relying on language features which just print out the source in certain cases.
• using error messages or STDERR to write all or part of the quine. (You may write things to STDERR or produce warnings/non-fatal errors as long as STDOUT is a valid quine and the error messages are not part of it.)
• the source code consisting purely of literals (whether they be string literals, numeric literals, etc.) and/or NOPs.

Any non-suppressible output (such as copyright notices, startup/shutdown messages, or a trailing line feed) may be ignored in the output for the sake of the validity of the quine.

Example

Ignoring the rule which forbids literal-only programs and built-in quining, this would be a metaquine in Seriously:

"Q"

The program consists of the single string literal "Q", which is implicitly printed at output. When the output (Q) is run, it is a quine (Q is the built-in quine function).

Answer 1

CJam, 6 bytes

"_p"_p

Prints

"_p"
_p

which is the shortest proper quine in CJam.

Test it here.

Explanation

Both programs work exactly the same, since the linefeed inside the proper quine is a no-op and only included because it's more expensive to remove it from the output. How the programs work:

"_p"  e# Push this string.
_     e# Duplicate it.
p     e# Print a string representation of the top of the stack (i.e. the string with
      e# quotes) followed by a linefeed.
      e# The other copy is then printed automatically at the end of the program, without
      e# stringifying it.

Side Note

The same works in GolfScript as

".p".p

which prints

".p"
.p

with a trailing linefeed, which in turn is one of the shortest known quines.

Answer 2

Pyth, 12 11 10 9 bytes

Knocked off one more byte thanks to @Pietu1998.

jN B".[9N

This prints

.[9N".[9N

which is a quine in Pyth. You can try it out here.

Answer 3

Fission, 6 bytes

!+OR"'

Prints

'!+OR"

Which is the shortest Fission quine. This works because cyclic shifts of the program leave its output completely unaffected.

Try it online!

Answer 4

Javascript ES6, 21 bytes

$=_=>`$=${$};$()`
$()

Trivial.

Answer 5

Python 2, 29 bytes

_="_=%r;print _%%_";print _%_

Turns out the well-known short python quine is easily turned into a metaquine :)

And, since we don't have to worry about matching the trailing newline, the metaquine is actually shorter!

Answer 6

Japt, 15 13 bytes

Q+"+Q ³s7J" ²

Test it online!

This program outputs

"+Q ³s7J"+Q ³s7J

which is the shortest known quine in Japt.

How it works

Q+"..." // Take a quotation mark plus this string.  "+Q ³s7J
²       // Repeat it twice.                         "+Q ³s7J"+Q ³s7J
        // Implicit output

Non-competing version, 11 bytes

Q+"+Q ²é" ²

I've just added é, a "rotate" command. So

"+Q ²é"+Q ²é

is now a valid quine.

Answer 7

7, 2 bytes, language postdates challenge

The program is two bytes long, and can be interpreted in several ways; as a hex dump:

00000000: 4ff4                                     O.

as codepage 437:

O⌠

or, most readably, in octal (which 7 natively uses):

237723

Try it online!

The workings of this are very simple: it's the standard 7 quine with a no-op stack element inserted between the two halves, to make it different (in this context, 7 separates stack elements). (I could also have inserted it at the start, 723723. I couldn't have interpreted it at the end because trailing 7s are like trailing whitespace, and ignored in the packed encoding, thus it wouldn't be any different from the output program.)

Incidentally, this program is a palindrome in hexadecimal, but that's mostly just coincidence.

Answer 8

Underload, 11 bytes

(:aSS)::aSS

Pretty simple. It prints out (:aSS):aSS, which is the standard Underload quine.

Answer 9

Brachylog, 12 bytes

"~k;?w₁"gjw₃

Try it online!

One of 132 same-length metaquine variations on the quine I translated from Fatalize's Brachylog v1 (non-cheating) quine. I actually wrote a (non-golfed, and overall silly) program to print all of them out:

{[[";?","gj","jḍ"],"₁₃₅₇"]j∋ᵐ{ḍ≠&};"\"~~k~ww~w\"~ww~w~n"}ᶠ{lw" metaquines generated:
"ẉ&}w₁ᵐ

Try it online!

There are two parts of the original quine which could be replaced inconsequentially: ;? can be changed to gj or jḍ, and ₁ can be changed to ₃, ₅, or ₇. If we keep or change them outside the string literal in one way and inside the string literal in a different way, then the output won't match the source, because whichever variants were present within the string literal will be printed both inside and outside it, resulting in a quine which was not the initial program run.

;?, gj, and jḍ are interchangeable because all three pair the string literal with itself: due to the layout of the program, the input variable ? is unified with the string, so ;? pairs the string with itself; regardless of the layout, gj wraps the string in a list which is then concatenated to itself; likewise jḍ concatenates the string to itself then splits it in half.

The odd-numbered w subscripts are interchangeable because, although originally w could only take 0 or 1, with 0 printing the input to w and 1 printing the first element formatted with the second, the subscript inventory for w has grown into something that externally functions as a bitfield: the low bit of the subscript encodes whether it's direct or formatted, the middle bit encodes whether the output variable from w is unconstrained or set to the input, and the high bit encodes whether the printing is done immediately or if it's delayed until the end of the program so it can be subject to backtracking. (Those subscripts were my first and so far largest contribution to Brachylog.) Since the quine and metaquine don't use the output variable and don't backtrack, all four odd subscripts are equivalent.

Answer 10

Ruby, 25 23

puts"puts <<2*2,2
"*2,2

Generates the classic Ruby HEREdoc quine

puts <<2*2,2
puts <<2*2,2
2

Old solution

_='_=%p;$><<_%%_';$><<_%_

Generates itself except with the single quotes replaced with double quotes.

Answer 11

JavaScript, 50 bytes

a="a=%s;console.log(a,uneval(a))";eval(a.slice(5))

Based on the shortest non-source-reading JS quine known to man, but a good 8 bytes shorter. Prints

a="a=%s;console.log(a,uneval(a))";console.log(a,uneval(a))

which is a quine.

Answer 12

Fish (><>), 17 bytes

This works using the classic fish quine "r00g!;oooooooo| but adds a { which shifts the entire stack to the left so that the original program isn't a quine, but it's output, when run, is.

"{r00g!;oooooooo|

Outputs:

"r00g!;oooooooo|

which is a fish quine!

Answer 13

Jelly, 3 bytes (non-competing)

Unfortunately, the required atoms are roughly 2 weeks younger than the challenge.

Metaquine

”Ṙv

Try it online!

How it works

”Ṙv  Main link. No arguments.

”Ṙ   Set the left argument and the return value to the character 'Ṙ'.
  v  Dyadic eval; evaluate the return value with the left argument as argument.
     Executing the atom Ṙ on the argument 'Ṙ' prints a string representation of
     the character, i.e., the string "”Ṙ".
     Finally, v returns its unaltered argument, which is printed implicitly.

Quine

”ṘṘ

Try it online!

How it works

”ṘṘ  Main link. No arguments.

”Ṙ   Set the left argument and the return value to the character 'Ṙ'.
  Ṙ  Print a string representation of the character, i.e., the string "”Ṙ".
     (implicit) Print the unaltered return value.

Since the second Ṙ prints the first two characters (”Ṙ), this is a proper quine by our definition.

Answer 14

Octopen-Baru, 22 bytes

** Non competing answer

愛[35211].pack歩U')

Ruby output

puts [35211].pack(' U')

Which outputs 見. Which is a quine in Octopen-Baru!

Answer 15

Lua, 45 bytes

Quine code not mine.

s="s=%qprint(s:format(s))"print(s:format(s));

will result in

s="s=%qprint(s:format(s))"print(s:format(s))

which is a quine. Glad the ; is optional in Lua.

Answer 16

Pushy, 7 bytes

Non-competing as the language postdates the challenge.

This is the standard quine, but with newlines removed. Newlines mean nothing in Pushy, but are the print operator's standard separator, and therefore needed for a true quine.

95 34_"

Try it online! This outputs:

95 34
_"

Which is the shortest Pushy quine - an explanation on how it works can be found here.

Alternatively, H5-34_" works for the same byte count.

Answer 17

Foam, 14 bytes

[. .'|: ~|]: ~

This prints the second Foam quine that can be found here. This is actually shorter because . will always put a space between each element, but the bar in the third token allows me to omit the space before it.

Answer 18

Husk, 6 bytes

D"S+s¨

Try it online!

Prints the standard Husk quine S+s"S+s".

 "S+s¨    The string S+s"
D         concatenated with itself.

The quine explained:

   "S+s"    The string S+s
 +          concatenated with
S           itself passed through
  s         the function which returns its string representation.

Answer 19

Befunge-93, 22 bytes

"+1_@#`+39:,g0:">:#,_@

I just took the standard quine, put it in quotes, reversed it (so it is loaded on the stack correctly), and then added a stack-print at the end.

It's 8 characters added to the normal quine, so it's very possible there's a better solution.

Answer 20

Turtlèd, 52 bytes (noncompeting)

1 less than original quine

@##'@r,r,r-{ +.r_}r{ +.r_}"#'@r,r,r-{ +.r_}r{ +.r_}"

Works in the same way, except that it does not have a character at the end, when run, it will have a character at the end, that does not effect output, because it writes # on to a #. Note the output is slightly different to the quine I have made for the quine challenge, but works the same: " writes #, which is its own last character, like the quine I made. Check out the explanation there.