Quine of orders

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