# 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)
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!"? – Mateen Ulhaq May 3 '11 at 2:49
• @muntoo it's a play on "Learn you a Haskell for Great Good". – Rafe Kettler May 3 '11 at 2:52

# beeswax, 17 13 bytes

Non-competing answer, beeswax is from 2015.

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
_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.

# Vitsy, 1198 6 Bytes

This programming language was obviously made past the date of release for this question, but I thought I'd post an answer so I can a) get more used to it and b) figure out what else needed to be implemented.

'rd3*Z

The explanation is as follows:

'rd3*Z
'           Start recording as a string.

(wraps around once, capturing all the items)

'           Stop recording as a string. We now have everything recorded but the original ".
r          Reverse the stack
b3*       This equates the number 39 = 13*3 (in ASCII, ')
Z      Output the entire stack.

# Fuzzy Octo Guacamole, 4 bytes

_UNK


I am not kidding. Due to a suggestion by @ConorO'Brien, K prints _UNK. The _UN does nothing really, but actually sets the temp var to 0, pushes 0, and pushes None.

The K prints "_UNK", and that is our quine.

• I was bored today and decided to quine in FOG. Couldn't figure it out, this is very clever – Bald Bantha Jun 26 '16 at 19:43

# C++, 286284 236 bytes

Now with extra golf!

#include<iostream>
int main(){char a[]="#include<iostream>%sint main(){char a[]=%s%s%s,b[]=%s%s%s%s,c[]=%s%sn%s,d[]=%s%s%s%s;printf(a,c,b,a,b,b,d,b,b,b,d,b,b,d,d,b);}",b[]="\"",c[]="\n",d[]="\\";printf(a,c,b,a,b,b,d,b,b,b,d,b,b,d,d,b);}


I'm currently learning C++, and thought "Hey, I should make a quine in it to see how much I know!" 40 minutes later, I have this, a full 64 114 bytes shorter than the current one. I compiled it as:

g++ quine.cpp


Output and running:

C:\Users\Conor O'Brien\Documents\Programming\cpp
λ g++ quine.cpp & a
#include<iostream>
int main(){char a[]="#include<iostream>%sint main(){char a[]=%s%s%s,b[]=%s%s%s%s,c[]=%s%sn%s,d[]=%s%s%s%s;printf(a,c,b,a,b,b,d,b,b,b,d,b,b,d,d,b);}",b[]="\"",c[]="\n",d[]="\\";printf(a,c,b,a,b,b,d,b,b,b,d,b,b,d,d,b);}


# Cheddar, 56 bytes

var a='var a=%s;print a%@"39+a+@"39';print a%@"39+a+@"39


Try it online!

I felt like trying to make something in Cheddar today, and this is what appeared...

# 05AB1E, 16 17 bytes

"34çs«DJ"34çs«DJ


With trailing newline.

Try it online!

Explanation:

"34çs«DJ"        # push string
34ç     # push "
s«   # swap and concatenate
DJ # duplicate and concatenate


# 05AB1E, 19 bytes

Thanks to @Oliver for a correction (trailing newline)

"D34ç.øsJ"D34ç.øsJ


There is a trailing newline.

Try it online!

"D34ç.øsJ"             Push this string
D            Duplicate
34          Push 34 (ASCII for double quote mark)
ç         Convert to char
.ø       Surround the string with quotes
s      Swap
J     Join. Implicitly display

• Try it online! - codegolf.stackexchange.com/a/161069/59376 - If you want to post this 22 byte answer on this question, you can :). Don't feel I deserve the credit. – Magic Octopus Urn Apr 2 '18 at 17:47
• Probably wasn't available in the old version of 05AB1E yet when you posted your answer, but you can golf 2 bytes by changing sJ (swap, join) to ì (prepend). Try it online. – Kevin Cruijssen Sep 7 '18 at 12:17
• @KevinCruijssen Thanks. I like to keep the language as it was before the challenge (even though that's not required anymore), so I'll leave it as it is – Luis Mendo Sep 7 '18 at 13:21
• @LuisMendo Fine by me. There are already two shorter 05AB1E answers anyway. Was just stating it as a possibility. :) – Kevin Cruijssen Sep 7 '18 at 13:24

# ಠ_ಠ, 6 bytes

ಠಠ


This used to work back when the interpreter was still buggy but that's fixed now. However, you can try it in the legacy version of the interpreter!

• It seems that ಠ also works in the interpreter provided. Also, ಠ is 3 bytes in UTF-8 – Conor O'Brien Aug 19 '16 at 21:53
• Your link is dead, and can you upload the language source to GitHub so that it can be added to TIO? – Pavel Jan 30 '17 at 4:28
• codepen.io/molarmanful/pen/rxJmqx all the code happens to be there. – Mama Fun Roll Jan 30 '17 at 17:58

# Clojure, 91 bytes

((fn [x] (list x (list (quote quote) x))) (quote (fn [x] (list x (list (quote quote) x)))))


# Mathematica, 68 bytes

Print[#<>ToString[#,InputForm]]&@"Print[#<>ToString[#,InputForm]]&@"


# Husk, 8 bytes

S+s"S+s"


Try it online!

Husk is a new golfing functional language created by me and Zgarb. It is based on Haskell, but has an intelligent inferencer that can "guess" the intended meaning of functions used in a program based on their possible types.

### Explanation

This is a quite simple program, composed by just three functions:

S is the S combinator from SKI (typed) combinator calculus: it takes two functions and a third value as arguments and applies the first function to the value and to the second function applied to that value (in code: S f g x = f x (g x)).

This gives us +"S+s"(s"S+s"). s stands for show, the Haskell function to convert something to a string: if show is applied to a string, special characters in the string are escaped and the whole string is wrapped in quotes.

We get then +"S+s""\"S+s\"". Here, + is string concatenation; it could also be numeric addition, but types wouldn't match so the other meaning is chosen by the inferencer.

Our result is then "S+s\"S+s\"", which is a string that gets printed simply as S+s"S+s".

# C (gcc), 787066 62 bytes

Minus 4 bytes thanks to MD XF (reusing first argument of printf)!

There are a few unprintables in this answer, replaced with ?.

main(){printf("main(){printf(%c%s%1$c,34,'@??');}",34,'@??');}  Here's an xxd: 00000000: 6d61 696e 2829 7b70 7269 6e74 6628 226d main(){printf("m 00000010: 6169 6e28 297b 7072 696e 7466 2825 6325 ain(){printf(%c% 00000020: 7325 3124 632c 3334 2c27 4005 9027 293b s%1$c,34,'@..');
00000030: 7d22 2c33 342c 2740 0590 2729 3b7d       }",34,'@..');}


Here's a bash script to generate and execute the program.

## 62 bytes, part 2

Here's a version that I have tested on my windows machine on gcc (ANSI encoded):

main(){printf("main(){printf(%c%s%1$c,34,'@@0');}",34,'@@0');}  Here's the output: C:\Users\Conor O'Brien\Documents λ xxd test.c 00000000: 6d61 696e 2829 7b70 7269 6e74 6628 226d main(){printf("m 00000010: 6169 6e28 297b 7072 696e 7466 2825 6325 ain(){printf(%c% 00000020: 7325 3124 632c 3334 2c27 4040 3027 293b s%1$c,34,'@@0');
00000030: 7d22 2c33 342c 2740 4030 2729 3b7d       }",34,'@@0');}

C:\Users\Conor O'Brien\Documents
λ cat test.c
main(){printf("main(){printf(%c%s%1$c,34,'@@0');}",34,'@@0');} C:\Users\Conor O'Brien\Documents λ wc test.c -c 62 test.c C:\Users\Conor O'Brien\Documents λ gcc test.c -o test test.c:1:1: warning: return type defaults to 'int' [-Wimplicit-int] main(){printf("main(){printf(%c%s%1$c,34,'@@0');}",34,'@@0');}
^
test.c: In function 'main':
test.c:1:8: warning: implicit declaration of function 'printf' [-Wimplicit-function-declaration]
main(){printf("main(){printf(%c%s%1$c,34,'@@0');}",34,'@@0');} ^ test.c:1:8: warning: incompatible implicit declaration of built-in function 'printf' test.c:1:8: note: include '<stdio.h>' or provide a declaration of 'printf' test.c:1:55: warning: multi-character character constant [-Wmultichar] main(){printf("main(){printf(%c%s%1$c,34,'@@0');}",34,'@@0');}
^

C:\Users\Conor O'Brien\Documents
λ test
main(){printf("main(){printf(%c%s%1$c,34,'@@0');}$c,34,'@@0');}
C:\Users\Conor O'Brien\Documents
λ


main(){printf("main(){printf(%c%s%1$c,34,4195728);}",34,4195728);}  I have no idea why this works, 100% honest here. But dang, is it short. Only 6 bytes longer than the current best. Try it online! ## 70 bytes main(){printf("main(){printf(%c%s%c,34,4195728,34);}",34,4195728,34);}  Try it online! ## 78 bytes main(){printf("main(){printf(%c%s%c,34,%c%c+8,34,34,34);}",34,""+8,34,34,34);}  Try it online! • 66 bytes – MD XF Jul 25 '17 at 4:46 • It works because printf is very weakly typed, so your integer constant gets interpreted as the actual pointer address of the format string constant. Very implementation-dependent, I tried it on a different Linux machine and even there I needed to adjust the numbers. – Ørjan Johansen Jul 25 '17 at 6:21 • @ØrjanJohansen Thanks, I figured it had something to do with addressing. – Conor O'Brien Jul 25 '17 at 16:39 • Aha, you found out how to get it down to 62 non-locally! – MD XF Jul 25 '17 at 17:03 • @MDXF Yes I did :> – Conor O'Brien Jul 25 '17 at 17:15 # JavaScript (ES6), 28 26 bytes Run this code in Firefox 34+ (currently in Aurora)'s Web console (f=x=>alert(f=${f})())()

• @rafe-ketler - I believe that this is the shortest ES6 version now :) – Optimizer Sep 13 '14 at 22:50
• Hmm... doesn't work in the latest version of Firefox (it outputs (f=,)()), I believe you'd have to put the template in parentheses. – ETHproductions Aug 11 '17 at 19:34

# Implicit, 20 bytes

«@171%@187»@171%@187


This didn't work in older versions of Implicit.

Try it online!

### How it works

«@171%@187»           Push the string '@171%@187' on the stack. Let's call it s.
@171       Print '«' (char code 171), without pushing it on the stack.
%      Print s without popping it from the stack.
@187  Print '»' (char code 171), without pushing it on the stack.
(implicit) Print the top of the stack: s.


# Implicit, 26 bytes

«:171,::187,"»:171,::187,"


Try it online!

### How it works

«:171,::187,"»              Push the string ':171,::187,"' on the stack.
Let's call it s.
:171          Push 171 (code point of «).
,         Swap s and 171.
:        Push a copy of s.
:187    Push 187 (code point of »).
,   Swap the copy of s and ».
"  Combine the entire stack into a string.

• +1, got the same solution not long after. – ATaco Sep 22 '17 at 2:31

## Bash + coreutils, 18 bytes

sed p<<a
sed p<<a


It requires a trailing newline and generates a warning.

Posted the Zsh version in a separate answer to fix the leaderboard.

• Interesting use of the here-document, but one has to end the text stream manually with Ctrl+D to make the script run, hence the warning. To have it run automatically, an extra line with just a on it is required, but that would break the quine. – seshoumara Sep 7 '16 at 8:53
• @seshoumara Just put it in a script file and use bash filename to run. – jimmy23013 Sep 7 '16 at 9:22
• Aah, you give an EOF this way, nice. Maybe add that to description. I run it with bash script 2> /dev/null to get rid of STDERR. – seshoumara Sep 7 '16 at 9:31
• In dash and zsh, you don't need the trailing newline and it won't generate a warning. – Dennis Sep 8 '16 at 15:49
• @seshoumara Answers on this site should be functions or complete programs, and not code snippets in a REPL, by default. – jimmy23013 Sep 8 '16 at 21:12

# Alchemist, 720 657 637 589 bytes

-68 bytes thanks to Nitrodon!

0n0n->1032277495984410008473317482709082716834303381684254553200866249636990941488983666019900274253616457803823281618684411320510311142825913359041514338427283749993903272329405501755383456706244811330910671378512874952277131061822871205085764018650085866697830216n4+Out_"0n0n->"+Out_n4+nn+n0n
4n0+4n0+n->Out_"n"
n+n+4n0+n0+n0+n0->Out_"+"
n+n+n+4n0+n0+n0->Out_n
4n+4n0+n0->Out_"4"
4n+n+4n0->Out_"\""
4n+n+n+n0+n0+n0->Out_"->"
4n+n+n+n+n0+n0->Out_"\n"
4n+4n+n0->Out_"Out_"
4n+4n+n->Out_"\\"
nn->4n0+4n0+nnn
n0+n4->n
nnn+4n+4n+n4->nn+n00
nnn+0n4->n+n40
n40+0n00+n4->n4+nn
n40+0n+n00->n4+n40


Try it online!

Warning, takes far longer than the lifetime of the universe to execute, mostly cause we have to transfer that rather large number on the first line back and forth between multiple atoms repeatedly. Here's a version that outputs the first few lines in a reasonable amount of time.

Here is the encoder that turns the program into the data section

Everything but the large number on the first line is encoded using these 8 9 tokens:

0 n + -> " \n Out_ \ 4


That's why all the atom names are composed of just n,0 and 4.

As a bonus, this is now fully deterministic in what order the rules are executed.

### Explanation:

Initialise the program
0n0n->        If no n0n atom (note we can't use _-> since _ isn't a token)
n4+Out_"0n0n->"+Out_n4+nn4+n0n
NUMn4           Create a really large number of n4 atoms
+Out_n4         Print the really large number
+nn             Set the nn flag to start getting the next character
+n0n            And prevent this rule from being called again

Divmod the number by 9 (nn and nnn flag)
nn->4n0+4n0+nnn          Convert the nn flag to 8 n0 atoms and the nnn flag
n0+n4->n                 Convert n4+n0 atoms to an n atom
nnn+4n+4n+n4->nn+n00     When we're out of n0 atoms, move back to the nn flag
And increment the number of n00 atoms
nnn+0n4->n+n40           When we're out of n4 atoms, add another n atom and set the n40 flag

Convert the 9 possible states of the n0 and n atoms to a token and output it (nn flag)
n+4n0+4n0->Out_"n"           1n+8n0 -> 'n'
n+n+4n0+n0+n0+n0->Out_"+"    2n+7n0 -> '+'
n+n+n+4n0+n0+n0->Out_n       3n+6n0 -> '0'
4n+4n0+n0->Out_"4"           4n+5n0 -> '4'
4n+n+4n0->Out_"\""           5n+4n0 -> '"'
4n+n+n+n0+n0+n0->Out_"->"    6n+3n0 -> '->'
4n+n+n+n+n0+n0->Out_"\n"     7n+2n0 -> '\n'
4n+4n+n0->Out_"Out_"         8n+1n0 -> 'Out_'
4n+4n+n->Out_"\\"            9n+0n0 -> '\'

Reset (n40 flag)
n40+0nn+n00->n4+n40    Convert all the n00 atoms back to n4 atoms
n40+0n00+n4->n4+nn     Once we're out of n00 atoms set the nn flag to start the divmod

• n0 and n4 should never exist at the same time without nnn, so the explicit catalyst is unnecessary in the twelfth line. Also, the literal "0" can be replaced by n (which you have 0 of), though this is version dependent. – Nitrodon Feb 5 at 20:45
• I had another idea just now. The nn flag can be completely replaced by n. – Nitrodon Feb 6 at 19:38
• @Nitrodon Great idea! That golfed a lot of bytes off – Jo King Feb 7 at 2:23

# Amazon Alexa, 31 words (non-competing)

Non-competing since a digital assistant isn't really a programming language.

Alexa, Simon Says Alexa, Simon Says
Alexa, Repeat That
Alexa, Simon Says Alexa, Repeat That Alexa, Simon Says, Alexa, Repeat That Alexa, Simon Says
Alexa, Repeat That
Alexa, Simon Says quiet


(each command is on a newline)

When said out loud to a device with the Amazon Alexa digital assistant enabled (I've only tested this on the Echo Dot though), it should say the same words back to you. There will be some different lengths of pauses between words, as you wait for Alexa to reply, and it says everything without breaks, but the sequence of words are the same.

### Explanation:

Each line is a new Alexa command, one of either:

• Alexa, Simon Says ..., which will prompt Alexa to say everything afterward the command
• Alexa, Repeat That, which repeats the last thing Alexa said

(neither of these appear on most lists of Alexa commands, so I hope someone has actually learned something from this)

We can simplify this to the commands S and R respectively, separated by spaces. For example, SR will represent Alexa, Simon Says Alexa, Repeat That. The translation of our program would be:

SS R SRSRS R SQ


Where Q is quiet (but can be anything. I chose quiet because that's what Alexa produced when I tried to give it quine, and it fit, so I kept it). Step by step, we can map each command to the output of each command:

Commands: SS
Output:   S
Commands: SS R
Output:   S  S
Commands: SS R SRSRS
Output:   S  S RSRS
Commands: SS R SRSRS R
Output:   S  S RSRS  RSRS
Commands: SS R SRSRS R    SQ
Output:   S  S RSRS  RSRS Q
Total Commands: SSRSRSRSRSQ
Total Output:   SSRSRSRSRSQ


The general approach for this was to get the output ahead of the input commands. This happens on the second to last command, which gets an extra S command. First we have to get behind on output though. The first two commands SS R only produce SS, leaving us to make up the R. However, this allows us to start a S command with an R, which means we can repeat a section (RSRS) multiple times, which allows us to get the spare S leftover. After that, all we had to do was use it to say whatever we wanted.

• Can Alexa do addition and primality checks? If so, then Alexa is a programming language according to PPCG – MilkyWay90 Mar 26 at 0:27
• @MilkyWay90 Yes, Alexa can do both those things, but I still hesitate to call it a programming language since those are both "built-ins", and Alexa is incapable of basic data storage and input. – Jo King Apr 15 at 5:49
• This is really a nice idea, but i don't think that it would be a valid quine if it is a valid programming language. In a valid quine, the spaces (or pauses) must also be the same, so if you had a second Alexa which only hears the output of the first Alexa, it should say the same as the first Alexa for a valid quine. The different pauses lead to different commands. You enter S("S"); R(); S("RSRS"); R(); S(); and you get S(); S(); R("SRS"); R("SRS"); – Dorian Jun 3 at 11:00

## 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!). – Martin Ender May 23 '17 at 15:35
• Agreed @MartinEnder, but the challenge does not specify proper quines. – bkul Jun 2 '17 at 21:30

## Bash, 48 bytes

Q=\';q='echo "Q=\$Q;q=QqQ;eval$q"';eval $q  Try it online! • Hm the leaderboard gives a shorter one, although that one uses sed while you are only using builtins. – Ørjan Johansen Feb 7 '18 at 17:14 • After a search, I think this is currently the shortest with only builtins and a "normal" quine construction. – Ørjan Johansen Feb 7 '18 at 17:28 • Thanks for taking a look @ØrjanJohansen! I'd like to differentiate this from the other solutions, but I don't know if I should change this title or the ones that use core utils... I'm happy with just coming up with the program to be honest! 😊 – Dom Hastings Feb 7 '18 at 19:22 • Bash + coreutils seems to be fairly common, so I'd suggest to edit the header of the other answer. – Laikoni Feb 10 '18 at 12:07 # 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.

# 05AB1E, 13 bytes

2096239D20BJ



Try it online!

Beats all the string-based 05AB1E quines.

Explanation:

2096239            # integer literal
D           # duplicate
20B        # convert the copy to base 20, yielding "D20BJ"
J       # join with the original


# 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. – Patrick Roberts Jul 16 '17 at 5:08
• This doesn't work as HTML has implicit html, head and body tags. – Konrad Borowski Mar 20 '18 at 16:20

# TeaScript, 1 byte

1


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

## TeaScript, 3 bytes

[q|


and if that's to boring...

(ƒ(${f})())()  # 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. – Conor O'Brien Sep 7 '16 at 1:56 • @ConorO'Brien Nope. The %s in the string only works with console.log. – ETHproductions Sep 7 '16 at 2:00 • ahhh that's what that was. – Conor O'Brien Sep 7 '16 at 11:02 • Lolp I was trying to do that a while ago, I couldn't figure out string formatting – Oliver Ni Oct 23 '16 at 5:26 ## C++, 117 bytes #include<cstdio> #define Q(S)char*q=#S;S Q(int main(){printf("#include<cstdio>\n#define Q(S)char*q=#S;S\nQ(%s)",q);})  • What compiler does this use? This does not appear to work on gcc. – Sriotchilism O'Zaic Jan 13 '17 at 15:26 • It works on my gcc 4.9.2. – Ralph Tandetzky Jan 13 '17 at 15:38 • Ok. According to clang, this is not valid C++, since the return type of main() is missing. I fixed that now. – Ralph Tandetzky Jan 13 '17 at 15:40 • My version of gcc was 4.2.1 (I should update some time). Now that main has a return type it works. – Sriotchilism O'Zaic Jan 13 '17 at 15:47 # 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.

# 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


# 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.