# 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
• Did anybody notice that this is question 69? – aidan0626 Oct 24 '20 at 22:47

# Reflections, 1.81x10375 bytes

Or to be more accurate, 1807915590203341844429305353197790696509566500122529684898152779329215808774024592945687846574319976372141486620602238832625691964826524660034959965005782214063519831844201877682465421716887160572269094496883424760144353885803319534697097696032244637060648462957246689017512125938853808231760363803562240582599050626092031434403199296384297989898483105306069435021718135129945 bytes.

The relevant section of code is:

+#::(1   \/  \    /: 5;;\
>v\>:\/:4#+     +\
/+#   /   2 /4):_    ~/
\ _   2:#_/ \  _(5#\ v#_\
*(2 \;1^    ;;4) :54/
\/ \    1^X    \_/


Where each line is preceeded by 451978897550835461107326338299447674127391625030632421224538194832303952193506148236421961643579994093035371655150559708156422991206631165008739991251445553515879957961050469420616355429221790143067273624220856190036088471450829883674274424008061159265162115739311672254378031484713452057940090950890560145649762656523007858600799824096074497474620776326517358755429533782443 spaces. The amount of spaces is a base 128 encoded version of the second part, with 0 printing all the spaces again.

Edit: H.PWiz points out that the interpreter probably doesn't support this large an integer, so this is all theoretical

### How It Works:

+#::(1  Pushes the addition of the x,y coordinates (this is the extremely large number)
Dupe the number a couple of times and push one of the copies to stack 1
\
>
Pushes a space to stack 2
*(2
\/

/  \
>v >:\
/+#   /   2   Print space number times
\ _   2:#_/

#      Pop the extra 0
\;1^   Switch to stack 1 and start the loop

/:4#+      +\
/4):_     ~/    Divide the current number by 128
\  _(5#\ v      Mod a copy by 128
^      4) :
\_/

v#_\  If the number is not 0:
^    ;;4) :54/  Print the number and re-enter the loop

/: 5;;\
v\      4             If the number is 0:
4             Pop the excess 0
:            \       And terminate if the divided number is 0
\     1^X


Conclusion: Can be golfed pretty easily, but maybe looking for a better encoding algorithm would be best. Unfortunately, there's basically no way to push an arbitrarily large number without going to that coordinate.

• Does the interpreter support integers this large? – H.PWiz Mar 25 '18 at 0:42
• @H.PWiz, erm, probably not. The interpreter is written in JS, which has a max integer size of 2^53-1 – Jo King Mar 25 '18 at 0:52
• Nevermind support for large integers. Where and how are you going to store the file? :P – Dennis Mar 25 '18 at 1:58
• Now I really want to prove that this answer is highly suboptimal, but first I have to learn the language... – user202729 Apr 1 '18 at 13:52
• Since V8 added support for BigInts, the interpreter integer limit should no longer be a problem - provided you can find a computer that can handle it. – Etheryte May 7 '18 at 8:49

# Brain-Flak, 1805 bytes

(())(()()()())(())(())(()()())(())(())(()()()())(())(())(()()()())(())(()()())(()())(()()())(())(()()()())(())(())(())(())(())(()())(()()()())(()())(()()())(())(()()()())(())(())(()()()())(())(()()())(()())(())(()()())(()()())(())(())(()()())(())(())(())(())(())(()()()())(())(())(()()())(())(())(())(()()())(()()())(()()()())(())(()()())(()())(())(()()())(())(())(())(())(())(()()())(()()()())(())(()())(())(()()())(()())(()()())(()()()())(())(()()())(())(())(())(())(()()())(()()()())(()())(())(()())(()()())(())(()())(()())(())(())(())(())(())(())(())(()())(())(()()())(())(())(()())(())(())(())(())(()()()())(()())(())(()()())(())(())(()()())(()())(())(()()())(()())(())(())(())(()())(())(())(()()())(()())(()())(()()()()())(()())(()())(()())(()()()())(())(())(()()())(())(())(()()())(()())(())(())(()()())(()())(()())(())(())(()()())(())(())(()())(())(()())(())(()())(())(()())(())(()())(()())(()())(()())(()()()())(())(()())(())(()()())(()())(()())(()()()())(()())(())(())(()())(()()()()())(()()())(())(()())(()())(())(())(())(()()())(())(())(()()()())(())(())(()()()())(())(()()())(()())(()()())(())(()()()())(())(())(()()()())(())(())(())(())(()())(()()()()())(())(())(()())(())(()()())(()())(()())(()())(())(()()()())(())(())(()())(())(()()())(()())(()()())(()()()())(())(()())(())(())(())(()()())(()()()()())(()())(()())(())(()()()())(())(())(())(()())(()()()()())(())(())(()())(())(()()())(())(())(()()())(())(())(()()())(())(())(()())(())(()())(())(()())(())(()())(())(()())(()())(()())(()())(()())(()())(())(()()()())(()()()){<>(((((()()()()()){}){}){}())[()])<>(([{}])()<{({}())<>((({}())[()]))<>}<>{({}<>)<>}{}>)((){[()](<(({}()<(((()()()()()){})(({})({}){})<((([(({})())]({}({}){}(<>)))()){}())>)>))((){()(<{}>)}{}<{({}()<{}>)}>{}({}<{{}}>{})<>)>)}{}){{}({}<>)<>{(<()>)}}<>{({}<>)<>}{}}<>



Try it online!

-188 bytes by avoiding code duplication

Like Wheat Wizard's answer, I encode every closing bracket as 1. The assignment of numbers to the four opening brackets is chosen to minimize the total length of the quine:

2: ( - 63 instances
3: { - 41 instances
4: < - 24 instances
5: [ -  5 instances


The other major improvement over the old version is a shorter way to create the code points for the various bracket types.

The decoder builds the entire quine on the second stack, from the middle outward. Closing brackets that have yet to be used are stored below a 0 on the second stack. Here is a full explanation of an earlier version of the decoder:

# For each number n from the encoder:
{

# Push () on second stack (with the opening bracket on top)
<>(((((()()()()()){}){}){}())[()])<>

# Store -n for later
(([{}])

# n times
{<({}())

# Replace ( with (()
<>((({}())[()]))<>

>}{}

())

# If n was not 1:
((){[()]<

(({}())<

# Using existing 40, push 0, 91, 60, 123, and 40 in that order on first stack
<>(({})<(([(({})())]((()()()()()){})({}{}({})(<>)))({})()()())>)

# Push 2-n again
>)

# Pop n-2 entries from stack
{({}()<{}>)}{}

# Get opening bracket and clear remaining generated brackets
(({}<{{}}>{})

(<

# This gives us the closing bracket
({}(){()(<{}>)}

# Move second stack (down to the 0) to first stack temporarily and remove the zero
<<>{({}<>)<>}{}>

# Push closing bracket
)

# Push 0
>)

# Push opening bracket
)

# Move values back to second stack
<>{({}<>)<>}

# Else (i.e., if n = 1):
>}{})

{

# Create temporary zero on first stack
(<{}>)

# Move second stack over
<>{({}<>)<>}

# Move 0 down one spot
# If this would put 0 at the very bottom, just remove it
{}({}{(<()>)})

# Move second stack values back
<>{({}<>)<>}}{}

}

# Move to second stack for output
<>

• It looks like you have a stray newline at the end of your code. You can save a byte by removing it. – 0 ' Dec 28 '17 at 18:55
• @0 ' Since Brain-Flak prints with a trailing newline. It is necessary for it to be a quine – H.PWiz Jan 19 '18 at 18:32

# 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 '19 at 20:45
• I had another idea just now. The nn flag can be completely replaced by n. – Nitrodon Feb 6 '19 at 19:38
• @Nitrodon Great idea! That golfed a lot of bytes off – Jo King Feb 7 '19 at 2:23

# Brian & Chuck, 211 143 138 133 129 98 86 84 bytes

?.21@@/BC1@c/@/C1112BC1BB/@c22B2%C@!{<?
!.>.._{<+>>-?>.---?+<+_{<-?>+<<-.+?ÿ


Try it online!

old version:

?{<^?_>{_;?_,<_-+_;._;}_^-_;{_^?_z<_>>_->_->_*}_-<_^._=+_->_->_->_-!_	?_;}_^_}<?
!.>.>.>.+>._<.}+>.>.>?<{?_{<-_}<.<+.<-?<{???=


Try it online!

New code. Now the data isn't split into nul separated chunks, but the nul will be pulled through the data.

Brian:
?                   start Chuck

.21@@/BC1@c/@/C1112BC1BB/@c22B2%C@!
data. This is basically the end of the Brian code and the Chuck code reversed
and incremented by four. This must be done because the interpreter tries
to run the data, so it must not contain runnable characters

ASCII 3 for marking the end of the code section
{<?                 loop the current code portion of Chuck

Chuck:
code 1 (print start of Brian code)
.>..               print the first 3 characters of Brian

code 2 (print the data section)
{<+>>-              increment char left to null and decrement symbol right to null
for the first char, this increments the question mark and decrements the
ASCII 1. So the question mark can be reused in the end of the Chuck code
?>.                 if it became nul then print the next character
---?+<+             if the character is ASCII 3, then the data section is printed.
set it 1, and set the next char to the left 1, too

code 3 (extract code from data)
{<-                 decrement the symbol left to the nul
?>+<<-.             if it became nul then it is the new code section marker, so set the old one 1
and print the next character to the left
+?                  if all data was processed, then the pointer can't go further to the left
so the char 255 is printed. If you add 1, it will be null and the code ends.
ÿ                   ASCII 255 that is printed when the end of the data is reached


# Whitespace, 338 bytes

-3 bytes thanks to Dorian pointing out a mistake





Try it online!

Not really much to see, but the code is there. This terminates with a 'Can't return from subroutine' error, which is only about 10 or so bytes extra to remove. Translated from whitespace, the tokens are:

push 213928514417226051472880134683878051755207959239232598316788086
push 2
call PRINT_SPACE
call PRINT_SPACE
call DIV_MOD_PRINT
push 1

label DIV_MOD_PRINT
copy 2nd item in stack
copy 2nd item in stack
div
jump if zero to POP_AND_PRINT_SPACE
copy 2nd item in stack
call DIV_MOD_PRINT
mod
dupe
jump if zero to POP_AND_PRINT_SPACE
push 8
print as character
return

label POP_AND_PRINT_SPACE
pop
label PRINT_SPACE
push 32
print as character
return


This starts off by pushing a rather large number in binary spaces and tabs. This number represents the rest of the program in trinary (since Whitespace has 3 valid characters), with space being 0, tab being 1 and newline as 2.

The main part of this code is the DIV_MOD_PRINT function, which assumes that the large number and the divisor is on top of the stack. This makes a copy of the two elements, then divides the number by the divisor and recursively calls the function again, returning once the result of the division is zero. On the tail call, this takes the two copied elements and gets the remainder after division. Then it maps it to the representation above.

This function is reused twice on the large number we pushed at the beginning, once with the divisor 2 to print the number itself in tabs and spaces, and again with 3 to print the rest of the program.

There are a couple of caveats; for example, we can't represent leading spaces with leading zeroes, so we with have to print those manually before we call the function the first time. This is partially mitigated by the fact that we stop the recursion by jumping to the POP_AND_PRINT_SPACE label, which means that we print a leading space anyway.

However, that causes one of the modulo pairs not to be evaluated, therefore the last character represented is not printed. This is actually a good thing, for a couple of reasons. First, since the binary number representation is terminated with a newline which would have had to have been printed (since we print a leading space), instead, if we ensure the last character of the binary number is a space, the newline is now the first character of the rest of the program. We can make the last character a space easily, since we aren't printing the last character of the program by adding a space or tab when encoding the number literal.

For reference, my encoding program, my commented program, and I used WhiteLips to debug the program.

# Klein, 330 bytes

"![	.;	=90*/[	.9(#;	=[>[.	>1#	98='9[	'7[.>;	[*;	)	=#0,*[	=.>9(.	=*(#(#([	.0#8;#(#;	[*9>[;	=> [*?	[9(;;"\
/																																																																																																														<
>:1+0\
/:)$< >\?\ / ?2$
:9>(:\
(8\/?<
\+ <
*
>$1-+\ >/?:) / >+)$)$)\ /1$9<$)$<
\+:?\<
>?!\+@
\:)<<



Try it online!

This works in all topologies, mostly by completely avoiding wrapping. The first list encodes the rest of the program offset by one, so newlines are the unprintable (11).

# Befunge 98 - 17 11 characters

<@,+1!',k9"


Or if using g is allowed:

# Befunge 98 - 12 10

<@,g09,k8"

• Explanation for why using g may not be allowed? – MD XF Jun 9 '17 at 23:56
• @MDXF g is arguably reading the source code. Befunge copies the code to the execution space and g reads the character at the x, y position in the execution space – Justin Jun 11 '17 at 6:50

# Lua, 44 bytes

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


Some other comical answers in Lua:

print(arg[0])


...so long as the file is named print(arg[0]) And...

Lua: quine.lua:1: function arguments expected near '.'


...so long as the file is named quine.lua

# Commodore Basic, 54 41 characters

1R─A$:?A$C|(34)A$:D♠"1R─A$:?A$C|(34)A$:D♠


Based on DLosc's QBasic quine, but modified to take advantage of Commodore Basic's shortcut forms. In particular, the shorter version of CHR$(34) makes using it directly for quotation marks more efficient than defining it as a variable. As usual, I've made substitutions for PETSCII characters that don't appear in Unicode: ♠ = SHIFT+A, ─ = SHIFT+E, | = SHIFT+H. Edit: You know what? If a string literal ends at the end of a line, the Commodore Basic interpreter will let you leave out the trailing quotation mark. Golfed off 13 characters. Alternatively, if you want to skirt the spirit of the rules, 1 LIST  LIST is an instruction that prints the current program's code. It is intended for use in immediate mode, but like all immediate-mode commands, it can be used in a program (eg. 1 NEW is a self-deleting program). Nothing shorter is possible: dropped spaces or abbreviated forms get expanded by the interpreter and displayed at full length. • Its not opening the file and reading its input, but I do agree that this is a bit cheaty. – yyny Feb 26 '15 at 21:34 • @MartinBüttner, is the new version better? – Mark Feb 27 '15 at 7:53 • @Mark I can't read that, but it looks like a quine to me. ;) – Martin Ender Feb 27 '15 at 9:06 • @YoYoYonnY It reads its source, tho. – Erik the Outgolfer Jun 28 '16 at 21:54 ## Julia, 37 bytes x=:(print("x=:($x);eval(x)"));eval(x)


Now that I know a bit more Julia, I thought I'd revisit this... due to the way printf works in Julia, my previous approach is clearly unsuitable. Instead we make use of (the tip of the iceberg of) Julia's homoiconic features. We define a symbol (that is, a representation of Julia code) which prints the framework of the code, as well as the contents of the variable x (via interpolation) and store that symbol in x. Then we eval that symbol. Much better. :)

# Jolf, 4 bytes

Q«Q«
Q    double (string)
«   begin matched string
Q« capture that


This transpiles to square(Q«) (I accidentally did string doubling in the square function), which evaluates to Q«Q«. Note that q is the quining function in Jolf, not Q ;).

# 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]]&@"


# 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

# APL (Dyalog Unicode), 18 bytesSBCS

@ngn's updated version of the classic APL quine, using a modern operator to save four bytes.

1⌽,⍨9⍴'''1⌽,⍨9⍴'''


Try APL!

'''1⌽,⍨9⍴''' the characters '1⌽,⍨9⍴'

9⍴ cyclically reshape to shape 9; '1⌽,⍨9⍴''

,⍨ concatenation selfie; '1⌽,⍨9⍴'''1⌽,⍨9⍴''

1⌽ cyclically rotate one character to the left; 1⌽,⍨9⍴'''1⌽,⍨9⍴'''

# 1+, 54244978480841123962 3748 bytes

11+1+1+1+1+1+11+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+11+1+1+1+1+1+1+1+1+1+1+1+1+1+1+11+1+1+1+1+1+1+1+1+1+1+1+1+1+1+11+1+1+1+1+1+1+1+1+11+1+1+1+1+1+1+1+1+1+1+1+1+1+1+11+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+11+1+1+1+1+1+1+11+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+11+1+1+1+1+1+11+1+1+1+1+1+1+1+1+1+1+1+1+1+1+11+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+11+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1111+1+1+1+1+1+1+1+1+1111+1+1+1+1+1+1+1+11+1+1+1+1+1+1+1+1+11+1+1+1+1+1+1+1+1+111+1+1+1+1+1+1+1+11+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+11+1+1+1+1+1+1+11+1+1+1+1+1+11+1+11+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+11+1+1+1+1+1+1+1+1+1+1+1+1+1+1+11+1+1+1+1+1+1+1+1+11+1+1+1+1+1+1+1+1+1+1+1+1+1+1+11+1+1+1+1+1+1+1+1+1+1+1+1+1+1+11+11+1+1+1+1+1+11+1+1+1+1+1+1+1+1+1+1+1+1+1+1+11+1+1+1+1+1+1+11+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1111+1+1+1+1+1+1+1+1+1111+1+1+1+1+1+1+1+11+1+1+1+1+1+1+1+1+1111+1+1+1+1+1+1+1+11+1+1+1+1+1+1+1+1+11+1+1+1+1+1+1+1+1+11+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+11+1+1+1+1+1+1+1+1+1+1+1+1+1+1+11+11+1+1+1+1+1+1+1+1+1+1+1+1+1+1+11+1+1+1+1+1+1+1+1+111+1+1+1+1+1+1+1+1+1+1+1+1+11+1+1+1+1+1+1+1+1+1+1+1+1+111+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+11+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+11+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+11+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+11+1+1+1+1+1+1+1+1+1+1+1+1+1+1+11+1+1+1+1+1+1+1+1+1+1+1+1+1+1+11+1+1+1+1+1+1+1+1+11+1+1+1+1+1+1+1+11+11+1+1+1+1+1+11+1+1+1+1+1+1+11+1+1+1+1+1+1+1+11+1+1+1+1+1+1+1+1+11+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+11+1+1+1+1+1+1+11+1+1+1+1+1+11+1+1+11+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+11+1+1+1+1+1+11+1+1+1+1+1+1+11+11+1+1+1+1+1+11+1+1+1+1+1+1+1+1+1+1+1+1+1+1+11+1+1+1+1+1+1+11+1+1+1+1+1+11+1+11+1+1+1+1+1+1+111+1+1+1+1+1+1+1+1+1+1+1+1+1+1+11+1+1+1+1+1+1+1+1+11+1+1+1+1+1+1+1+1+1+1+1+1+1+1+11+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+11+11+1+1+1+1+1+1+11+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+11+1+1+1+1+1+11+1+1+1+11+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+11+1+1+1+1+1+11+1+1+1+1+1+1+11+11+1+1+1+1+1+1+1+1+1+1+1+1+1+1+11+1+1+1+1+1+1+1+1+1+1+1+1+1+1+11+1+1+1+1+1+1+1+1+111+1+1+1+1+1+1+1+111+1+1+1+1+1+1+1+111+1+1+1+1+1+1+1+1+11+1+1+1+1+1+1+1+1+11+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+11+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+111+1+1+1+1+1+1+1+1+1+1+1+1+1+1+11+1+1+1+1+1+1+1+1+11+1+1+1+1+1+1+1+1+1+1+1+1+1+1+11+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+11+11+1+1+1+1+1+1+(|11+1<)$$1|1""+""*++"*;)(|1+11#(1)1""+""*+""*++;1#1+"//"\^\<11+*#()*+$$(%|()#(1)($)"1+1<#)\(&|()#11+"*"*"++;\"1+1<#)  Try it online! • Congratulations! You beat me to the punch. Nice work!! – null Oct 6 '19 at 1:42 # Pyth, 9 8 bytes p+N "p+N  Saved one more byte by using the newline operator (Also I made this ages ago but forgot to edit this so yeah) Try it online! # 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]• J jump to row=1st,column=2nd val.[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!