Write a program that, when run in different languages, outputs a different byte permutation of the code in each language. The exact source code is counted as one permutation.

Here "different language" can be different version(Py 2 and Py 3) or different standard flags. It's different output that forces different version.

Proper quine rules apply for the program in each language. Your score is calculated as (Language count)^6/(Code length in bytes), with a higher score being better.


If your code is AAB and running in three different languages returns ABA, AAB and AAB, then its score is 2^6/3(only one of the two AAB count). It's fine if ABA is meaningless.

  • 1
    \$\begingroup\$ What counts as a different language? \$\endgroup\$
    – Laikoni
    Commented Apr 12, 2018 at 9:24
  • 4
    \$\begingroup\$ Which definition of a proper quine applies? (Martin's, or ais523's, or maybe some other definition in these meta threads?) Do the proper quine rules apply only to interpretations of the program that are actually quines? (For what it's worth, I don't think this challenge is improved much by enforcing proper quine rules.) \$\endgroup\$
    – lynn
    Commented Apr 12, 2018 at 9:28
  • \$\begingroup\$ To clarify, working on your example — if my code AAB prints AAB in language-1 and ABA in language-2, I assume that it must be a proper quine when viewed as a language-1 program, and there are no further restrictions involving its interpretation as a language-2 program. Is that right? \$\endgroup\$
    – lynn
    Commented Apr 12, 2018 at 9:31
  • 1
    \$\begingroup\$ Is code length counted in characters or bytes? What should we do with different character encodings? \$\endgroup\$
    – dylnan
    Commented Apr 12, 2018 at 19:34
  • 1
    \$\begingroup\$ What about bytes vs. characters? \$\endgroup\$
    – dylnan
    Commented Apr 13, 2018 at 3:41

5 Answers 5


Befunge-98, ><>, Gol><>, Fission, Wumpus, Cardinal, Beeswax and Alice Score: 86/88 = 2978.909

"65*4+059*$!#.39*0jp2+'Wk,@ ''5&.'\d&o@o&88#+\@ol?!,'.'0.6'!+Ox,++tttt=++%-$#}.6~.F4*`*R

Try it in Befunge! Try it in ><>! Try it in Gol><>! Try it in Fission! Try it in Wumpus! Try it in Cardinal! Try it in Beeswax! Try it in Alice!


Lots of 2D languages, all abusing wrapping string literals. The difference in outputs are thus:

><>, Gol><> and Befunge-98 all print the code backwards (except for the "), with the last three characters in different positions, R*", O"* and "R* respectively. Beeswax also has the code backwards, but the last three characters are interspersed in the first section of the output. Alice is mostly backwards, except for all the escaped characters (',\ and ") moved to the front instead.

Wumpus is the only actual quine, Fission puts the " at the end of the code instead of the beginning, and Cardinal puts the " between the 0 and the 5 near the start.

Proof of different permutations



"  Wrapping string literal pushes all other characters + a space to the stack
 65*4+  Push " to the stack
      059*$!#.39*0j   Push 1,27 to the stack
                   p  Pops the top three values of the stack (27,1,34)
                    2+  Adds 2 to the space to make "
                      'Wk,@  Prints the top 88 characters of the stack and terminates

><> and Gol><>:

To be honest, I didn't do much here. The only difference between the execution of these two languages is the @ command, which rotates the top three values of the stack in different ways for each language.

"  Wrapping string literal pushes all other characters to the stack
 65*4+  Push 34 (") to the stack
      059*$!#.  Jump to cell 45,0
                                   \@  Rotate the top three values of the stack 
                                     ol?!,'.'0.  Output the whole stack, ending in a divide by 0/stack underflow error


 "............R  Spawn a pointer going right

 "  Switch to printing mode and print every other character
 "  Switch off printing mode
  6  Teleport to other 6
 "........6'!+O   Print the "


"  Bouncing string literal
 65*4+  Push a (")
      059*$!#.   Push 0 and jump to cell 0,45
                                        \  Reflect off mirror
                                       +   Add 0 to top of stack
                                 @o&88#    Print the top 88 characters of the stack


                                 %   Spawn two pointer going left/right (up/down despawn immediately)
                                  -$  Right pointer jumps to cell -1,0
                      x,++tttt=++     Left pointer prints "
"  While right pointer switches to print mode and prints the code


 "................*`*   Spawn pointers going in every direction
                        Every other * also spawns pointers, but they do nothing
                   `    Turn on print mode for two of the pointers going in different directions
                        This prints everything but the `
          #}.6~.F4*     Print a `


"  Wrapping string literal pushes all other characters to the stack
   Except 's and mirrors
 65*4+  Push " to the stack
      059*$!#.  Does nothing
              39*0j  Jumps to cell 39,0
                         ''5&.    Push ' and duplicate it 5 times
                              '\  Push \
                                d&o@  Print the whole stack

Perl 5, Ruby, JavaScript (Chrome), PHP, Python 2, Python 3, 1206 bytes, score 66/1206 = 38.6865671641791

eval($_='"$t"?0?[$q=37 .chr+113 .chr+38 .chr,$p=(96 .chr+39 .chr)*4,$n=10 .chr,$s=39 .chr*12,$S=34 .chr*3]:eval("printf=console.log;c=String.fromCharCode;$q=c(96);$p=c(37,113,38,39).repeat(4);$n=c(10);$s=c(39).repeat(12);$S=c(34,34,34)"):[]?[$q=q(!g)^PA,$p=HARHARHARHAR^od2od2od2od2,$n=R^X,$s=bbbbbbbbbbbb^EEEEEEEEEEEE,$S=hhh^JJJ]:[$q=O^h,$p=str_repeat(RHa3^w9GS,4),$n=R^X,$s=str_repeat(b^E,12),$S=HHH^jjj];//#');printf($x='q=1//2;s=+0;s|0;"/.__id__;#";_=%7$sq=1//2;s=+0;s|0;"/.__id__;#";_={0}{1}{0};R=chr((39,34)[1/2>0])*12;Q=chr((39,34)[1/2==0])*3;q={0}{2}{0};print(_.format(Q,_,q[0:-12]+R,"%8$s"))%7$s;R=chr((39,34)[1/2>0])*12;Q=chr((39,34)[1/2==0])*3;q=%7$s|;#<?ob_end_clean();%5$seval($_=%3$s%1$s%3$s);printf($x=%3$s%2$s%3$s,$_,$x,$q,$p,$n,$s,$S,"%8$s",![]||([]+[])?$n:"");//#%4$s%6$s%7$s;print(_.format(Q,_,q[0:-12]+R,"%8$s"))%9$s',$_,$x,$q,$p,$n,$s,$S,"%",![]||([]+[])?$n:"");//#`q&%`q&%`q&%`q&%''''''''''''""";print(_.format(Q,_,q[0:-12]+R,"%"))

Validate Perl, Ruby, PHP, Python 2 and Python 3 online!

Note: running the above program in the Inspector console in Chrome (which appears to support positional arguments to console.log) returns the correct program.


This turned out a lot longer than I'd hoped and I made my life a little harder too, so I'm likely to keep tinkering with it. I'd like to add in more languages too, but I need to find something that doesn't mind a $ sigil...

This is pretty much a standard quine format where the calculation of the quote to use is a little different for each language: in Ruby %q& is used, PHP uses ', JavaScript (Node.js) makes use of ` and Perl 5 utilises q(...). Because only the quotes change, the rest of the program is still executable and valid syntax in each language. Python 2 and 3 are wrapped around the previous program using """ for Python 2 and ''' for Python 3.

The resultant Perl and Ruby programs aren't standard quines, additional q/%qs are added each iteration, but the first program returns correctly.

The results are:

  • Perl 5:
    eval($_=q&...q&);printf($x=q&...q&,...);//#'%`'%`'%`'%`''''''''''''""" ...
  • Ruby:
    eval($_=%q&...%q&);printf($x=%q&...%q&,...);//#`'`'`'`'''''''''''''""" ...
  • JavaScript (Chrome):
    eval($_=` ...`);printf($x=`... `,...);//#%q&'%q&'%q&'%q&'''''''''''''""" ...
  • PHP:
    eval($_='...');printf($x='...',...);//#`q&%`q&%`q&%`q&%''''''''''''""" ...
  • Python 2:
  • Python 3:

I've re-worked this a lot, I hope I haven't missed anything key here. I still have quite a way to go to be anywhere near Jo King's score...


Jelly, and M, 26/14 = 4.57


Try it in Jelly!

Try it in M!

Ɗṙ@ȮṾ1“Ɗṙ@ȮṾ1” in Jelly

1Ɗṙ@ȮṾ“1Ɗṙ@ȮṾ” in M

  • \$\begingroup\$ I'm not sure that the Charcoal one counts as a proper quine \$\endgroup\$
    – H.PWiz
    Commented Apr 12, 2018 at 17:13
  • \$\begingroup\$ @H.PWiz I was about to add a comment saying that. I'll ask OP \$\endgroup\$
    – dylnan
    Commented Apr 12, 2018 at 17:15
  • \$\begingroup\$ @l4m2 do you consider the Charcoal program a proper quine? I will delete if not. \$\endgroup\$
    – dylnan
    Commented Apr 12, 2018 at 17:16
  • \$\begingroup\$ I guess it's like Quine in PHP? \$\endgroup\$
    – l4m2
    Commented Apr 12, 2018 at 17:35
  • \$\begingroup\$ @l4m2 Not sure, I don't know PHP. It works for most ASCII text I think \$\endgroup\$
    – dylnan
    Commented Apr 12, 2018 at 17:38

Python 2 and Python 3, 26/61 =1.05


Try it in Python 2!

Try it in Python 3!

Saved 12 bytes thanks to Jo King.

Python 2 prints


Python 3 prints


This uses the fact that 1/2 is .5 in Python 3 and 0 in Python 2.


Bash/GolfScript, 72 bytes, score 26/72 = 8/9 (~0.888...)

.~0 () 
    declare "-f" @* ".~0" " ()
    echo '.~0;'

Contains a single trailing space on the first two lines.

Try it online in Bash.
Try it online in GolfScript.

Simply modification of @jimmy23013's answer for the "Write a Polyquine" challenge. The modification that was done was removing the trailing space after the third line, and changing \n"+@n.; to \n "+@n;.

Bash will print lines 1 and 2 like this:

.~0 ()    <- Trailing space
{         <- Trailing space

And GolfScript will print lines 1 and 2 like this:

.~0 ()   <- No trailing space
 {       <- Both leading and trailing space

Here the base program, Bash output, and GolfScript outputs respectively with the new-lines replaced with \n:

.~0 () \n{ \n    declare "-f" @* ".~0" " ()\n "+@n.;\n    echo '.~0;'\n}\n.~0;
.~0 () \n{ \n    declare "-f" @* ".~0" " ()\n "+@n.;\n    echo '.~0;'\n}\n.~0;
.~0 ()\n { \n    declare "-f" @* ".~0" " ()\n "+@n.;\n    echo '.~0;'\n}\n.~0;

      ^^^ Note the difference here

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service and acknowledge you have read our privacy policy.

Not the answer you're looking for? Browse other questions tagged or ask your own question.