# Golf you a quine for great good!

Using your language of choice, golf a quine.

A quine is a non-empty computer program which takes no input and produces a copy of its own source code as its only output.

No cheating -- that means that you can't just read the source file and print it. Also, in many languages, an empty file is also a quine: that isn't considered a legit quine either.

No error quines -- there is already a separate challenge for error quines.

Points for:

• Smallest code (in bytes)
• Most obfuscated/obscure solution
• Using esoteric/obscure languages
• Successfully using languages that are difficult to golf in

The following Stack Snippet can be used to get a quick view of the current score in each language, and thus to know which languages have existing answers and what sort of target you have to beat:

var QUESTION_ID=69;
var OVERRIDE_USER=98;

getAnswers();var SCORE_REG=(function(){var headerTag=String.raw h\d
var score=String.raw \-?\d+\.?\d*
var normalText=String.raw [^\n<>]*
var strikethrough=String.raw <s>${normalText}</s>|<strike>${normalText}</strike>|<del>${normalText}</del> var noDigitText=String.raw [^\n\d<>]* var htmlTag=String.raw <[^\n<>]+> return new RegExp(String.raw <${headerTag}>+String.raw \s*([^\n,]*[^\s,]),.*?+String.raw (${score})+String.raw (?=+String.raw ${noDigitText}+String.raw (?:(?:${strikethrough}|${htmlTag})${noDigitText})*+String.raw </${headerTag}>+String.raw ))})();var OVERRIDE_REG=/^Override\s*header:\s*/i;function getAuthorName(a){return a.owner.display_name}
body='<h1>'+c.body.replace(OVERRIDE_REG,'')+'</h1>'});var match=body.match(SCORE_REG);if(match)
valid.push({user:getAuthorName(a),size:+match[2],language:match[1],link:a.share_link,})});valid.sort(function(a,b){var aB=a.size,bB=b.size;return aB-bB});var languages={};var place=1;var lastSize=null;var lastPlace=1;valid.forEach(function(a){if(a.size!=lastSize)
if(languages.hasOwnProperty(lang))
langs.push(languages[lang]);langs.sort(function(a,b){if(a.uniq>b.uniq)return 1;if(a.uniq<b.uniq)return-1;return 0});for(var i=0;i<langs.length;++i)
{var language=jQuery("#language-template").html();var lang=langs[i];language=language.replace("{{LANGUAGE}}",lang.lang).replace("{{NAME}}",lang.user).replace("{{SIZE}}",lang.size).replace("{{LINK}}",lang.link);language=jQuery(language);jQuery("#languages").append(language)}}
body{text-align:left!important}#answer-list{padding:10px;float:left}#language-list{padding:10px;float:left}table thead{font-weight:700}table td{padding:5px}
 <script src="https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js"></script> <link rel="stylesheet" type="text/css" href="https://cdn.sstatic.net/Sites/codegolf/primary.css?v=f52df912b654"> <div id="language-list"> <h2>Winners by Language</h2> <table class="language-list"> <thead> <tr><td>Language</td><td>User</td><td>Score</td></tr></thead> <tbody id="languages"> </tbody> </table> </div><div id="answer-list"> <h2>Leaderboard</h2> <table class="answer-list"> <thead> <tr><td></td><td>Author</td><td>Language</td><td>Size</td></tr></thead> <tbody id="answers"> </tbody> </table> </div><table style="display: none"> <tbody id="answer-template"> <tr><td>{{PLACE}}</td><td>{{NAME}}</td><td>{{LANGUAGE}}</td><td><a href="{{LINK}}">{{SIZE}}</a></td></tr></tbody> </table> <table style="display: none"> <tbody id="language-template"> <tr><td>{{LANGUAGE}}</td><td>{{NAME}}</td><td><a href="{{LINK}}">{{SIZE}}</a></td></tr></tbody> </table> 

• Do you not mean, "Golf you a quine for greater good!"? May 3 '11 at 2:49
• @muntoo it's a play on "Learn you a Haskell for Great Good". May 3 '11 at 2:52
• Did anybody notice that this is question 69? Oct 24 '20 at 22:47

# Whispers v2, 38 bytes

> "print('> %r\\n>> ⍎1'%a)"
>> ⍎1



Try it online!

Abuses the fact that there's an eval as Python command (⍎), which I can use to turn it into an arbitrary Python program. But of course, as a less cheaty feeling quine, there's:

# Whispers v2, 270 bytes

> [62, 62, 32, 34, 49, 34, 10, 62, 32, 34, 62, 32, 34, 10, 62, 62, 32, 51, 43, 50, 10, 62, 62, 32, 69, 97, 99, 104, 32, 54, 32, 49, 10, 62, 62, 32, 39, 82, 10, 62, 62, 32, 79, 117, 116, 112, 117, 116, 32, 52, 32, 53]
>> "1"
> "> "
>> 3+2
>> Each 6 1
>> 'R
>> Output 4 5



Try it online!

Which encodes the ordinal values of the rest of the program on the first line, then prints the list then the list converted to characters.

Turns out I missed another way to make a slightly cheaty quine. In Whispers, the modulo command directly calls Python's %, which is overloaded with string formatting. This means you can forgo the eval command and do:

# Whispers v2, 50 bytes

> '> %r\n>> 1%%1\n>> Output 2'
>> 1%1
>> Output 2



Try it online!

# beeswax, 17 13 bytes

According to the discussion on Does using SMBF count as a cheating quine? the original version at the bottom would count as a cheating quine, so I am wondering if a small change would make this a “proper” quine. The new version is 4 bytes smaller and does not modify its own source code:

_4~++~+.}1fJ


Explanation:

                lstack     STDOUT

_             α[0,0,0]•                 create bees α,β, moving right and left
β[0,0,0]•

4            α[0,0,4]•                 push 4 on top of α lstack, switch β to print mode
β α            β[0,0,0]•                 switch β to character output mode

~           α[0,4,0]•                 flip α lstack top and 2nd
+          α[0,4,4]•                 lstack top = top+2nd
+         α[0,4,8]•                 lstack top = top+2nd
~        α[0,8,4]•                 flip lstack top and 2nd
+       α[0,8,12]•                lstack top = top+2nd
.      α[0,8,96]•                lstack top = top*2nd
}     α[0,8,96]•     ASCII(96) output char(lstack top) to STDOUT
1    α[0,8,1]•                 lstack top = 1
F   α[1,1,1]•                 all lstack = top
J  α[1,1,1]•                 jump to (x,y) = (lstack top, lstack 2nd)
_4~++~+.}1FJ  α[1,1,1]•   _4~++~+.}1FJ  output characters to STDOUT


This version should qualify as proper quine if the Befunge-93 program on Thompson’s Quine Page is listed as proper quine. The Befunge quine below does nothing else than read itself character by character, one character during each implicit loop, and output the character to STDOUT.

:0g,:93+#@_1+


Correct me if I’m wrong.

Old (cheating?) version.

beeswax is a new 2D esolang on a hexagonal grid. It is inspired by bees, honeycombs and by the Hive board game (which uses hexagonal gaming pieces). beeswax programs are able to modify their own code. Thanks to this ability it is not too hard to create a quine. But the program does not read its own source code, as my explanation shows.

The first beeswax quine in existence:

_4~++~+.@1~0@D@1J


Or equivalently:

*4~++~+.@1~0@D@1J


IPs are called bees, the program area is called honeycomb. Every bee owns a local stack called lstack, carrying 3 unsigned 64 bit integer values.

Explanation:

                                             lstack
• marks top of stack

* or _  create bee(same result in this situation)[0,0,0]•
4      1st lstack value=4                       [0,0,4]•
~        flip 1st/2nd lstack values            [0,4,0]•
++      1st=1st+2nd, twice                    [0,4,8]•
~                                           [0,8,4]•
+                                          [0,8,12]•
.         1st=1st*2nd                     [0,8,96]•
@  flip 1st/3rd lstack values            [96,8,0]•
1     1st=1                             [96,8,1]•
~                                      [96,1,8]•
0   1st=0                             [96,1,0]•
@                                    [0,1,96]•
D drop 1st at row=2nd,col.=3rd val. [0,1,96]•
This drops ASCII(96)=  beyond the left border.


Dropping a value at a coordinate outside the program—in this case at column 0—grows the honeycomb by 1 column to the left. The coordinate system gets reset, so this column becomes the new column 1. So, growing the honeycomb in ‘negative’ direction is only possible in steps of 1. The grown honeycomb is always a rectangle encompassing all code.

This modifies the program to:

*4~++~+.@1~0@D@1J


continuing...

               @                                  [96,1,0]•
1                                 [96,1,1]•
switch to character output mode.
*4~++~+.@1~0@D@1J    the following characters are printed to STDOUT.


GitHub repository of the Julia package of the beeswax interpreter.

• You can generate 96 using 5~3(. Try it online! (TIO still has the bug with the endof vs lastindex)
– Jo King
Sep 26 '20 at 23:22

# Ruby 2.7, 34 bytes

".tap{puts p _1}"
.tap{puts p _1}



Not the shortest Ruby quine, but I think it's quite cute so I'm posting it.

### Ruby, 35 bytes

END{p$0};$><<$0="END{p$0};$><<$0="



An alternative.

### Ruby, 27 bytes

p S if$><<S="p S if$><<S="



Another alternative. So close to tying the 25 world record!

## C++ (350)

#include<iostream>
#include<fstream>
int main(){std::ofstream f;f.open("f.cpp");
#define B(x)x;f<<("B(" #x ")");
#define A(x)f<<("A(" #x ")");x;
B(f<<("#include<iostream>\n#include<fstream>\nint main(){std::ofstream f;f.open(\"f.cpp\");\n#define B(x)x;f<<(\"B(\" #x \")\");\n#define A(x)f<<(\"A(\" #x \")\");x;\n"))A(f<<("f.close();}\n"))f.close();}


Modified version of this.

Makes use of the C++ preprocessor.

# Arcyóu, 1 byte

Q


The interpreter evaluates undefined symbols as strings, and the result of the last expression evaluated is automatically printed at the end of the program. What's interesting is that any undefined identifier can be used; I_am_a_quine! is also a quine.

• This does not satisfy our rules for proper quines as the Q only encodes itself (as does any character in I_am_a_quine!). May 23 '17 at 15:35
• Agreed @MartinEnder, but the challenge does not specify proper quines. Jun 2 '17 at 21:30

# Brachylog (2), 26 bytes, language postdates challenge

"ạ~bAh34∧A~ạj"ạ~bAh34∧A~ạj


Try it online!

A function that returns its own source code. (This can be made into a 28-byte full program by adding w after each occurrence of j.)

## Explanation

"ạ~bAh34∧A~ạj"ạ~bAh34∧A~ạj
"ạ~bAh34∧A~ạj"               String literal
ạ              Convert to list of character codes
~b            Prepend an element
h34          so that the first element is 34
A   ∧A        but work with the entire list
~ạ    Convert to string
j   Concatenate the string to itself


# Japt, 9 bytes

I've fantasized about a 9-byte Japt quine for years, and now it's finally snapped into place :-D

9îQi"9îQi


Test it online!

### Explanation

    "9îQi    Start with this string.               9îQi
Qi         Insert it before a quotation mark.    9îQi"
9î           Repeat until it reaches length 9.     9îQi"9îQi


# Befunge-93, 25 22 bytes

-2*6<>:#,_@#:-5: _-p<"


Try it online!

Thanks to jimmy23013's answer for inspiring the idea to create the " before the wrapping string literal.

Previous answers have usually relied on non-standard interpreter behaviour in order to wrap a string literal around the code and avoid the extra spaces. My quine however, is compliant with Befunge-93 specs.

Befunge-93 has a bounding box of 80x25 cells, which are initially filled with spaces. This means the wrapping string literal, a staple of 2D quines, usually fills the stack with a lot of excess spaces.

### How It Works:

-2*6<  Create the " character
" Start the wrapping string literal
_-p<  Pop all the spaces until there are none left
Note that p is the put command, which basically pops 3 items from the stack
:-5:  Dupe the 2 and subtract 5 to replace the - that was destroyed
Dupe that again to compensate for the _
>:#,_@#  Print until stack is empty and terminate


Alternatively:

++9*5<>:#,_@#::_$#-< "  also works for 22 bytes. # Whitespace, 406 bytes DISCLAIMER: This quine was not created by me, it is created by Smithers. Because this challenge was missing a Whitespace answer I decided to post his/her. If Smithers reads this and wants to post it himself/herself I will of course delete my answer. Sources: Smithers' website and his/her Whitespace quine source code (note: it's missing a trailing new-line). [S S S T S S T S T T T T T S T T T S S T T S S S T S T T S T T T T T T T S T S S S T S S T S S T S T T T T T S T S T S S S T T T S S T S T T S S S S T T T T T T S S T T T S T S T S S S T T T S S S S S S S T T T T T T T S T S S T S S S T S T T T T S S S S S T S T S S S T S T T S T S S S T S S T S S T T T S S S S S S S T T S T S S T T T T T S S S T T T T S S T T S T T S S T S T T T T S S S S T T S S T T T T S T S S T T S S T S S T T S S S S T T S S T T S S T S S T T S T S T S T T S S S T T S T S N _Push_67079405567184005086107571748115383207539763039497665210559156555730234138][S N S _Duplicate][N S T S N _Call_Label_PRINT_SPACE][N S T S N _Call_Label_PRINT_SPACE][S S S T S N _Push_2][S N T _Swap][N S T N _Call_Label_RECURSIVE_PRINTER][S S S T S T S N _Push_10][T N S S _Print_as_char][S N N _Drop][S S S T T N _Push_3][S N T _Swap][N S T N _Call_Label_RECURSIVE_PRINTER][N N N _Exit][N S S N _Create_Label_RECURSIVE_PRINTER][S N S _Duplicate][N T S T N _If_0_Jump_to_Label_DISCARD_TOP(_AND_PRINT_SPACE)][S T S S T N _Copy_1][S T S S T N _Copy_1][S T S S T N _Copy_1][T S T S _integer_divide][N S T N _Call_Label_RECURSIVE_PRINTER][T S T T _Modulo][S N S _Duplicate][N T S T N _If_0_Jump_to_Label_DISCARD_TOP(_AND_PRINT_SPACE)][S S S T S S S N _Push_8][T S S S _Add][T N S S _Print_as_character][N T N _Return][N S S T N _Create_Label_DISCARD_TOP(_AND_PRINT_SPACE)][S N N _Discard][N S S S N _Create_Label_PRINT_SPACE][S S S T S S S S S N _Push_32][T N S S _Print_as_character][N T N _Return]  Letters S (space), T (tab), and N (new-line) added as highlighting only. [..._some_action] added as explanation only. Try it online (with raw spaces, tabs and new-lines only). Whitespace is a stack-based language only using three characters: spaces, tabs and new-lines. In Whitespace the stack can only contain integers, and there are two options to print something to STDOUT: "Print as number" and "Print as character". In the case of "Print as character" it will print the character based on the unicode value at the top of the stack. Because whitespace uses spaces, tabs and new-lines, it means it'll have to print numbers 32, 9, and 10 respectively as characters to STDOUT for this quine. Smithers uses a pretty ingenieus piece of code with the magic number (s)he found. Pseudo-code: Push 67079405567184005086107571748115383207539763039497665210559156555730234138 Duplicate top Call function_PRINT_SPACE Call function_PRINT_SPACE Push 2 Swap top two Call function_RECURSIVE_PRINTER Push 10 Pop and print top as character Discard top Push 3 Swap top two Call function_RECURSIVE_PRINTER Exit program function_RECURSIVE_PRINTER: Duplicate top If 0: Call function_DISCARD_TOP(_AND_PRINT_SPACE) Make a copy of the 2nd top item of the stack Make a copy of the 2nd top item of the stack Make a copy of the 2nd top item of the stack Integer-divide top two Call function_RECURSIVE_PRINTER Modulo top two Duplicate top If 0: Call function_DISCARD_TOP(_AND_PRINT_SPACE) Push 8 Add top two Pop and print top as character Return function_DISCARD_TOP(_AND_PRINT_SPACE): Discard top function_PRINT_SPACE: Push 32 Pop and print top as character Return  It first uses a recursive-loop which keeps integer-dividing the initial integer by 2 until it's 0. Once it's 0, it goes back over these values and does modulo-2, printing either a space (if the modulo-2 resulted in 0) or a tab (by adding 8 to the modulo-2 result of 1). This first part is used to print the magic number itself, which only consists of spaces and tabs, because pushing a number in Whitespace is done as follows (and thus doesn't contain any new-lines except for the single trailing one): • S: Enable Stack Manipulation • S: Push a number • S/T: Positive/Negative respectively • Some S/T, followed by a trailing N: The number as binary, where S=0 and T=1 After it has printed the spaces and tabs required for pushing the magic number itself, it pushes a 3 and will use the same recursive function with the magic number, integer-dividing and using modulo 3 instead of 2. Which will print the spaces (if the modulo-3 resulted in 0), or tabs/new-lines (by adding 8 to the modulo-3 result). • You may be interested in my new Whitespace quine – Jo King Oct 8 '19 at 3:05 • @JoKing Very nice! Well done! :) Oct 8 '19 at 7:31 # Perl 6, 31 27 bytes <"<$_>~~.EVAL".say>~~.EVAL



Try it online!

No messing about with alternative q quotes or .perl, just <> and a good ol' EVAL quine.

### Explanation:

<                 >         # Create a list of
"<$_>~~.EVAL".say # The string '"<$_>~~.EVAL".say'
~~       # Smartmatch the list by setting $_ to it .EVAL # Evaluate the string as code "<$_>~~.EVAL"              # Interpolate the $_ list into the string .say # And print it with a newline  # Rust, 72 66 bytes fn main(){print!("{}{0:?})}}","fn main(){print!(\"{}{0:?})}}\",")}  Try it online! # Ruby, 27 bytes eval s="$><<'eval s=';p s"



Try it online!

$><<'...' is equivalent to print'...' (outputs the string without a newline). Note the newline at the end of the program. • Welcome to the site! Nice first answer :) Jun 12 '17 at 17:07 • doesn't p print a newline? Aug 11 '19 at 23:20 • @Shelvacu You're right; it should be 27 bytes. Interestingly, I went back and looked around, and I couldn't find any Ruby quines that included a newline in their source to match the output. Most seem to add an extra newline in their output like this one did. I also have a vague memory of coming across a 25-byte Ruby quine somewhere, I think in a demonstration of a new-at-the-time feature, but I haven't been able to find it again. Aug 12 '19 at 23:43 # 1+, 834 bytes (|11+"*"+"1+\1+/)("|1/()11+^)(2|\""++1+/()""+^)++<+/(#|\##"\+;1#()\^\1#)+<+()()(")(2)(2)()()(")()(2)(")(2)()(")()(")()()()(2)(")()()()(2)()()(2)()(")()()()()(2)(2)(")()()()(2)()()(2)()(")(2)()(")(2)(")()(")()()()(2)(")(2)(2)()(")()(2)(")()()()(2)()()(2)()(")(")()(")()(")()()()(2)()()(2)()(")(2)()(2)()(2)(")()(")(2)(")()()(2)()(")()(2)(")(2)(2)()()(")()(2)(")()(2)(")(2)()(")()()()()(2)(2)(")()(2)(")(")(")(2)()(")(2)(")()()(2)()(")()(2)(")()()()(2)(")()(2)(")()(2)(")(")(")()()()(2)()()(2)()(")(2)()(2)()(2)(")()()()(2)()(")(2)(")(2)()(")()()()()(2)(2)(")()(2)(")()()()(2)(")()()()(2)(")(2)()(")(2)(")()()(2)()(")()()()(2)(")(2)()(2)()(2)(")(")(2)(")(2)()(")()()(2)()(")()(2)(")()()()(2)(")()()()(2)()()(2)()(")()(2)(")()()()(2)(")(")()(2)(")(")(2)()()(")(")()(2)(")()()()(2)(")()()()(2)(")(2)()(2)()(2)(")(2)(")(2)()()(2)(")(")(#)@  Try it online! Defines all the subroutines before the data section, then calls the (#) subroutine at the end of the data. Instead of using 1s followed by totalling 1+s, we define subroutines for initialisation ((")), which pushes a 2 to the stack, incrementing (()), and doubling plus 2 (ironically, (2)). All of these also push the characters used to call the subroutine to the top of the stack to print after printing the rest. We also offset the data by 32, since all values are above that. This is most certainly suboptimal, especially since I've been steadily golfing it down from ~2000 bytes. I suspect it can be sub-500 eventually, or even lower with a different strategy. Here's my program encoder, though it needs some post-fiddling with the first value to make sense. ## Stax (packed), 43 bytes å3o╞╝&∞╝7►JôyG♦◄╨s│*T→╢φY'┘ò☼≤⌠░▼e╓Δ█•Aφ/│.  Try it online! ### Doesn't work because for some reason latin1 does not accept the C1 control codes. For this version, the interpreter needs to be forced to output in latin1. Stax Encoding is used. There is an extra trailing newline, but this appears to be accepted here (judging from many other answers). ### Explanation: The unpacked source is: "r{32-m2+c+95|EVB|EB128+s+"r{32-m2+c+95|EVB|EB128+s+  • The first half simply pushes the string which is also the second half. • The second half builds the full unpacked source out of it and packs it: r{32-m2+c+95|EVB|EB128+s+ Second half r{32-m Reverse and subtract 32 from each character (for packing) 2+ Append 2 (double quote - 32) c+ Concatenate with self 95|E Decode as a base 95 integer (for packing) VB|E Encode as a base 256 interager (for packing) B128+s+ Add 128 to the first byte (for packing) Implicit output  ## Stax (packed), 103 bytes (50 characters) üö╖╞╖┘û■Å╣ß$æi7⌐ê↔T)ç¢┤,I_º>┐ó♫Z╪Æ≤◄▐0σ▓☻E.α╬TÅ¶7É


Run and debug it

Source and output are UTF-8 here, so they are counted as such. Much longer, but UTF-8 is a little nicer to look at.

# convey, 54 bytes

'Z  u   u%+}12  !*]+|   |0]!&[&&Z'[
v
v&,~23
"+^,}
}1^"'\''[


Try it online!

As a bonus, I even managed to avoid using any unprintable characters, though there are a few tabs in there.

### Explanation

Here's an image of how the code is interpreted (the gif version would take too long, since it takes approximately 23*26=598 steps):

There are two starting conveyor belts here, indicated by the [s on the top and bottom lines. The one on the top line feeds the data string to the rest of the program, while the other one prints the leading ' for the string and adds the other quote to the buffered output.

The top row is fed through a duplicator ("), one side of which is just pushed to output, while the other one has each character incremented by one (+1) to be transformed into the rest of the program before entering a queue (&), which already contains a '. Each character in this queue is delayed by 23 steps (~23), so that it only starts printing after the initial data string has finished being printed.

# PHP-r, 32 bytes

Saved 3 bytes thanks to Sisyphus' insight!

The content of this quine is mostly unprintable characters using the stringwise NOT operator so the test link is to Bash to rebuild the file from an xxd hexdump.

eval(~$_=.....................);  Try it online! ## Explanation In PHP it's possible to use the ~ operator to 'flip' all the bits in a byte to return a string that doesn't look anything like the original string, which works around the problem of having to encode, and then decode, things like quotes. This means it's possible to just call echo on the result. Visual example of how ~ 'flips' the values. This was built using the following approach: $quine =
// plain beginning
"eval(~$$\_=". // flipped code with _ interpolated ~'echo"eval(~\$$_=$_);";' . // plain end ");" ;  Try it online! • 32 bytes - Try it online! Feb 5 at 0:21 • @Sisyphus Of course! I'll update this later. Thank you! It's quite a competitive quine now! Feb 5 at 7:19 # ed(1), 45 bytes We have quines for TECO, Vim, and sed, but not the almighty ed?! This travesty shall not stand. (NB: See also, this error quine for ed) Try it Online! a a , ,t1$-4s/,/./
,p
Q
.
,t1
$-4s/,/./ ,p Q  Stolen from here. It should be saved as a file quine.ed then run as follows: (TIO seems to work a bit differently) $ ed < quine.ed


# Grok, 42 bytes

iIilWY!}I96PWwI10WwwwIkWwwwIhWq
k   h


Try it Online!

It is very costly to output anything in Grok it seems.

# CSS, 47 bytes

<style>:before,*{display:block;content:'<style>


Paste into a blank HTML page to avoid conflict with other tags.

• Wouldn't this technically be HTML with embedded CSS in it? Also, what browser did this successfully quine in, because when I test this with an empty HTML file, it displays :before,*{display:block;content:'<style> on the window. Jul 16 '17 at 5:08
• This doesn't work as HTML has implicit html, head and body tags. Mar 20 '18 at 16:20

# SWI-Prolog, 22 bytes

a :-
listing(a).



A surprisingly short and elegant solution.

The 8 spaces and the new line (the space in the last line is just to display the empty line, there is actually no space) are both required in SWI-Prolog because that is the formatting that listing displays in the interpreter.

# TeaScript, 1 byte

1


Nothing too interesting. But if that's too boring...

## TeaScript, 3 bytes

[q|


and if that's to boring...

(ƒ(${f})())()  ## Python, 104 bytes Uses eval and repr a = "print 'a','=', repr(eval('a'))\nprint eval('a'),\n" print 'a','=', repr(eval('a')) print eval('a'),  • Since this is code-golf, you might want to include a byte count. Apr 28 '14 at 12:33 • repr(x)==x Mar 10 '16 at 23:58 # JavaScript, 58 54 bytes I present to you the shortest non-source-reading quine in JavaScript: console.log(a="console.log(a=%s,uneval(a))",uneval(a))  How have I not thought of this before? Screw that, how has nobody thought of this before? :P Here's a version that works in all browsers at the cost of 9 bytes: q='"';console.log(a="q='%s';console.log(a=%s,q,q+a+q)",q,q+a+q)  • If this works in the browser, you can make console.log be alert. Sep 7 '16 at 1:56 • @ConorO'Brien Nope. The %s in the string only works with console.log. Sep 7 '16 at 2:00 • ahhh that's what that was. Sep 7 '16 at 11:02 • Lolp I was trying to do that a while ago, I couldn't figure out string formatting Oct 23 '16 at 5:26 # BotEngine, 4x1=4 bytes TRUE  The T instruction deletes the active bot and prints TRUE. # Befunge-98 (cfunge), 8 characters  'k<@,k␇  ␇ represents a literal BEL character (ASCII 7, or Ctrl-G). (Note also that the program starts with a leading space.) Note that the k command, which is heavily used here, is somewhat imprecisely defined, and this code is outright exploiting several edge cases at once, making this an example of corner-case code. As such, this is somewhat interpreter-dependent; it doesn't work on TIO, for example. cfunge is the Befunge-98 interpreter I normally use locally (and has been tested to be highly conformant with the specification), and it handles this code correctly. (Update: I've been talking to some Befunge experts about this quine, and the consensus is that it's exploiting a bug in cfunge, not behaviour that's defensible by the specification. Still a valid answer, though, because languages are defined by their implementation and this is the sort of corner case that has no right answers, only wrong answers.) This program would also work in Unefunge-98 and Trefunge-98, but I'm not sure if any of the pre-existing interpreters for those handle k in the way we need, so it may be noncompeting in those languages. ## Verification $ xxd /tmp/quine.b98
00000000: 2027 6b3c 402c 6b07                       'k<@,k.
\$ ./cfunge /tmp/quine.b98 | xxd
00000000: 2027 6b3c 402c 6b07                       'k<@,k.


## Explanation

### General principles

We know that in fungeoids, it's normally easiest to wrap a string around the code, so that the code is inside and outside the string literal at the same time. However, another trick for shortening quines is to use a string representation which doesn't need escaping, so that we don't need to spend bytes to represent the string delimiter itself. So I decided to see if these techniques could be combined.

Befunge-98 normally uses " as a string delimiter. However, you can also capture a single character using ', and you can make any command into a sort of lightweight loop (in a confusing and buggy way) using k. As such, k' functions as a sort of makeshift length-prefixed string literal. And of course, a length-prefixed string literal has no problems in escaping its own delimiter, as it doesn't have any sort of string terminator at all, meaning that the entire range of octets (in fact, the entire range of cell values) are available to exist within the string.

We can actually do even better; we no longer have to stop the string at its opening delimiter (we can stop it anywhere), so we can wrap it multiple times around the program to grab not only the k' itself, but also the length of the string (which is in this case written as a character code, thus the literal backspace). The program will continue execution just after the end of the string, i.e. just after the last character captured, which is exactly where we want it. (Bear in mind that Befunge strings are printed in reverse order to pushing them; the most common form, NUL-terminated strings, are called "0gnirts" by the community because of this, and length-prefixed strings follow the same principle. Thus if we want the length to end up at the start of the string, we have to push it last.)

As an extra bonus, this also means that we can wrap multiple times around the program with no penalty; all that matters is that the last character we see is the string length (which is at the end of the program). By an amazing stroke of luck, k' specifies length-prefixed string (sort-of; k is weird), and 'k (the same two characters in reverse order) pushes 107, which happens to loop round the program multiple times and end up in exactly the right place (this only had a 1 in 8 chance of working out). Because we have to reverse the program direction anyway (to read the string in the reverse of the natural reading order, meaning that it gets printed in the same order it appeared in the original program), we can use the same two characters for both pushing the length, and pushing the string itself, at no cost.

Of course, this now captures a risk of counting as a literal-only program, and thus not a proper quine under PPCG rules. Luckily, wrapping round from one end of the program to the other produces a literal space character, and spaces at the ends of the line (i.e. leading and trailing whitespace) aren't captured as part of a string. Thus, if we start the program with a space, we can encode that space (which isn't part of the string literal) via the implicit space that we get from wrapping the program (i.e. the leading space is encoded by the ' next to it, rather than by itself), just sneaking within the proper quine rules. The easiest way to see this is to delete the leading space from the program; you'll get the same output as the program with the leading space (thus effectively proving that it doesn't encode itself, because even if you remove it it still gets printed).

### Detailed description

 'k<@,k␇
'k       Push 107 to the stack
<      Set execution delta to leftwards
'k       Push the next 107 characters to the stack: "'␠␇k, … @<ck'␠␇"
,k   Pop a length from the stack, output that many characters
,    Output the top stack element
@     Exit the program


You can note that k has some odd ideas of where to start reading the string from (for the first k that runs), or where to leave the IP afterwards (for the second k that runs); this is just the way k happens to work (you think of k as taking an "argument", the command to run, but it doesn't actually move the IP to skip the "argument"; so if the command inside the loop doesn't affect the IP or the IP's movement, it'll end up being the next command that runs and the loop runs one more time). The literal BEL, ASCII 7, is interpreted by the second k as a loop counter, so the , inside the k will print the first 7 characters, then the , outside the k (which is the same character in the source) will print the 8th just before the program exits.

# Turtlèd, 68 6353 54 bytes (newlines)

rewrote

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



### Try it online!

Explanation

@#         Set character variable to #. Useful because this cannot occur in string var
#                        #  Set the string var to...
'@r,r,r-{ +.r_}r{ +.r_}'   This string (quotes included. coincidental)
'@r,r,r            Write out first three chars of program: @##
-{ +.r_}r   Write out the string var, then #, move right
{ +.r_} Write out the string var again, write #
'f   overwrite last # with f


# Alice, 45 bytes

Credit to Martin Ender for the use of %, r, and y to obtain the characters "/\ without escaping.

/?.!eO%?.*y1?@~mtz!!4\
\"Y!Z1hrZRoY@*m*h%1Y{/


Try it online!

This program runs entirely in ordinal mode. Because of how ordinal mode programs need to be formatted, this is significantly longer than Martin Ender's cardinal mode quine.

In ordinal mode, the instruction pointer moves diagonally, and commands work on strings instead of integers. The diagonal movement is what makes this tricky: there is even a challenge specifically about formatting a program for ordinal mode. While it's possible to sidestep the entire issue by putting the same string on both lines, this approach ends up slightly longer at 52 bytes.

\".!e1%r.Ryh?*.Ooo1m@z1!{
\".!e1%r.Ryh?*.Ooo1m@z1!{/


Try it online!

## Explanation

This is a standard template for ordinal mode, with an additional mirror to allow the program to loop back to the beginning. Linearized, the code is as follows:

".!e1%r.RyY?*~*t%!Y4?Y!ZOh?Z*o1@@mmhz1!{


As with many Fungeoid quines, the " wraps around to itself and puts this entire program in a string literal. Since string mode treats mirrors as mirrors (instead of literals), the string that gets pushed is exactly the linearized code, excluding the ".

.!     Duplicate the string, and move the copy to tape
e1%    Split on "1", placing "@@mmhz" and "!{" on top of the stack.
The other two parts are irrelevant.
r      Expand !{ into the entire range from code point 33 to 123.
.R     Duplicate and reverse this range
y      Modify the string @@mmhz by changing every character in the range 33-123
with the corresponding character in the reversed range.
The result of this transformation is \\//4" .
This allows us to get these characters without escaping them.
Y?*~*  Split this string in half by unzipping, and put the halves on either
side of the original string.  The new string is \/"sourcecode\/4 .
t%     Extract the newly added 4 at the end, and use it to split on the single 4 in the code.


At this point, we have two strings corresponding to approximately half of the code. The top of the stack has the second half of the program and the right side mirrors, and corresponds to these output bytes:

 ? ! O ? * 1 @ m z ! \
Y Z h Z o @ m h 1 {/


The string below that has the first half of the program, along with the left side mirrors and quote:

/ . e % . y ? ~ t !
\" ! 1 r R Y * * % Y


Neither string currently contains the 4 that was used to split the string.

!      Move second half string to the tape.
Y      Unzip first half: the top of the stack now contains the characters
from the first half that will end up in the first row of the output.
4      Append the digit 4 to this string.
?Y     Copy second half back from tape and unzip: the top of the stack contains
characters from the second half that will end up in the second row
!      Move this onto the tape.
Z      Zip the two halves of the first row together.
O      Output this with a linefeed.
h      Temporarily remove the initial \ so the next zip will work right.
?Z     Copy the string back from the tape, and zip the second row together.
This Z isn't the exact inverse of Y since the second half is longer.
The resulting behavior is exactly what we want.
*o     Join with the previously removed \ and output.
1      Append 1 to the irrelevant string on the top of the stack.
@      Terminate.


The 52-byte quine works on exactly the same principle, except that it doesn't need the ordinal formatting section of the 45-byte quine.

# Taxi, 1144 1034 970 bytes

"is waiting at Writer's Depot.34 is waiting at Starchild Numerology.Go to Starchild Numerology:w 1 r 3 l 2 l 3 l 2 r.Pickup a passenger going to Charboil Grill.Go to Charboil Grill:e 1 l.Pickup a passenger going to KonKat's.Go to Writer's Depot:w 1 r.Pickup a passenger going to KonKat's.Go to KonKat's:n 3 r 2 r.Pickup a passenger going to Cyclone.Go to Cyclone:n 1 l 2 l.Pickup a passenger going to Post Office.Pickup a passenger going to Post Office.Go to Post Office:s 1 l 2 r 1 l."is waiting at Writer's Depot.34 is waiting at Starchild Numerology.Go to Starchild Numerology:w 1 r 3 l 2 l 3 l 2 r.Pickup a passenger going to Charboil Grill.Go to Charboil Grill:e 1 l.Pickup a passenger going to KonKat's.Go to Writer's Depot:w 1 r.Pickup a passenger going to KonKat's.Go to KonKat's:n 3 r 2 r.Pickup a passenger going to Cyclone.Go to Cyclone:n 1 l 2 l.Pickup a passenger going to Post Office.Pickup a passenger going to Post Office.Go to Post Office:s 1 l 2 r 1 l.


Please ignore the output to stderr. Who needs a job if you can quine anyway?

Try it online!

# How does this work?

This quine starts with a string. If you replace the content of that string by <string>, the code looks like "<string>"<string>, which is "<string> twice. Because the string doesn't contain the double quote, we first get the double quote via its character code, concatenate it with the string, then copy the string and concatenate it with itself. Finally, we print the string.

under construction

# tinylisp, 88 bytes

The byte count includes a trailing newline.

((q (g (c (c (q q) g) (c (c (q q) g) ())))) (q (g (c (c (q q) g) (c (c (q q) g) ())))))


Try it online!

There are no strings in tinylisp, but a nontrivial quine is still possible because code is lists and lists are code. The above code is a list which, when evaluated, returns (and therefore prints) itself.

The idea is to pass the list (g (c (c (q q) g) (c (c (q q) g) ()))) to a function which will wrap it in a list, tack a q on the front, and then wrap two copies of that in a list. Which is exactly what the function (q (g (c (c (q q) g) (c (c (q q) g) ())))) does. In-depth explanation available on request, but I wanted to post this before turning in for the night.

# Awk, 64 bytes

BEGIN{c="BEGIN{c=%c%s%c;printf c,34,c,34}";printf c,34,c,34}