# 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

## Klein, 11 + 6 = 17 bytes

3 additional bytes for the topology argument 001 and another 3 for ASCII output -A.

:?/:2+@> "



Try it online!

Let's start with the topology. The 1 at the end indicates that the north and south edges of the code are mapped to each other in reverse. So if the IP leaves the code through the south edge in the leftmost column, it will re-enter through the north edge in the rightmost column. We use this to skip to the end of the program.

:             Duplicate the top of the stack (implicitly zero).
?             Skip the next command if that value is non-zero (which it isn't).
/             Reflect the IP north.
The IP leaves through the north edge in the third column from
the left, so it will re-enter from the south edge in the third
column from the right.
>             Move east.
":?/:2+@> "   Push the code points of the program, except for the quote itself
to the stack.
:             Duplicate the top of the stack, now a 32 (the space).
?             Skip the next command (the /).
:             Duplicate the top of the stack again.
2+            Add 2, to turn the space into a quote.
@             Terminate the program.


# JavaScript (ES6 REPL), 22 bytes

f=_=>"f="+f+";f()";f()


Idea stolen from Kendall Frey but in less bytes.

Since I cannot comment on his answer because I don't have rep I decided to make a new answer.

• Welcome to the site! – DJMcMayhem Jan 2 '17 at 17:56
• Save a byte with template literals: f=_=>'f=${f};f()';f() (replace single quotes with backticks). – Shaggy Apr 26 '17 at 16:11 • (f=_=>*(f=${f})()*)() to save one byte (swap * with "") – Brian H. Feb 20 '18 at 14:53

# Befunge-93, 1514 13 bytes

+9*5x:#,_:@#"


Works in this interpreter. x is an unrecognized command which reflects the instruction pointer.

Thanks to Jo King for saving 1 byte.

This 14 byte version works in FBBI:

+9*5<>:#,_:@#"


Try it online!

• This almost works, but doesn't: "gx:#,_:@#/3: (also 13 bytes). – jimmy23013 May 25 at 4:37

# brainfuck, 392 bytes

Like this 755B answer, this quine is accompanied by an additional character, which appears in both source and output. I tested this using BFO in the windows terminal emulator ConEMU.

->++>+++>+>+>+++>>>>>>>>>>>>>>>>>>>>+>+>++>+++>++>>+++>+>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>+>+>>+++>>+++>>>>>+++>+>>>>>>>>>++>+++>+++>+>>+++>>>+++>+>++>+++>>>+>+>++>+++>+>+>>+++>>>>>>>+>+>>>+>+>++>+++>+++>+>>+++>>>+++>+>++>+++>++>>+>+>++>+++>+>+>>+++>>>>>+++>+>>>>>++>+++>+++>+>>+++>>>+++>+>+++>+>>+++>>+++>>++[[>>+[>]++>++[<]<-]>+[>]<+<+++[<]<+]>+[>]++++>++[[<++++++++++++++++>-]<+++++++++.<]


Try it online!

The source and output have no linebreaks. The last character is a \x1a (SUB ctrl code).

Invented by Daniel B Cristofani.

How it works

Like many other brainfuck quines, this code first inputs a list of values that are later used to recreate the actual code, then it builds up a list that contains the "+" and ">" symbols needed for the input and then all characters are printed out.

Each character of the actual code (starting with +[) is stored in two cells. Let's call them x and y. The formula to calculate the current character is (x+2)*16 + (y+2) + 9, so the characters are encoded like this:

char ascii minus9 outX outY inX inY
+    43    34     2    2    0   0
-    45    36     2    4    0   2
.    46    37     2    5    0   3
<    60    51     3    3    1   1
>    62    53     3    5    1   3
[    91    82     5    2    3   0
]    93    84     5    4    3   2


All values are stored in reversed order. For example the starting ->++>+++>+>+>+++>> (2 3, 1 1, 3 0) encodes the .<] at the end of the code.

[tape: End Marker/EM(-1), [in values], Between Lists Marker(0), [out values]]

-                       set EM

[>++>+++>+>+>+++>>>>>>>>>>>.... ]

build out values to generate list
+[                      while input (for each gt)

append pluses to out vals / always runs one extra time
[                     while value gt 0 (for each plus)
>>+                 copy in value to out value
[>]++>++            append out values 2 2 (plus)
[<]<-               decrement in value
]

>+                    new out value 1 (for adding 2 to each in value / one by the extra loop and one by this)
[>]<+<+++             add 3 and 1 to last out values (change plus to gt)
[<]                   go to old in value
<+                    repeat if not on EM
]

>+[>]++++>++            append out value 4 2 (minus)
>[instead of ">+", we could also use ">>",
but a ">" is encoded as "+++>+>", while a "+" is encoded ">>",
so it saves four bytes, when using "+>".]<

printing loop
[
[<++++++++++++++++>-] add 16 times out value(X) to next out value(Y)
.                     print char
<                     go to next out value
]


The  in the end appears, because the copy routine leaves the extra values 1, 1 at the end of the list, which will be encoded 16+1+9 = 25. If we wanted to avoid that, we had to replace the >+ by the code >>->. The input code of that section would change from >>+++>+> to +++>+>++>>+++>+>+++>+>, so the code would be 15 bytes longer.

• The output is ASCII-only and has 392 bytes. The last byte, \x1a, is rendered as a right arrow in code page 437; it's not the same as the unicode right arrow \u2192. – Mitch Schwartz Jan 3 '16 at 20:20
• (Put another way, the 394-byte program ending with \xe2\x86\x92 is not a quine, but it prints the 392-byte quine ending with \x1a.) – Mitch Schwartz Jan 3 '16 at 20:38
• If you haven't written this yourself, I think it should be community wiki. – Martin Ender Jan 4 '16 at 15:29

## C, 78 chars

#define Q(S)char*q=#S;S
Q(main(){printf("#define Q(S)char*q=#S;S\nQ(%s)",q);})


This version is shorter than the familiar 79-character C quine and also doesn't assume ASCII. It does still assume that it's safe to not include stdio.h. (Adding an explicit declaration of printf() brings the length up to 103 chars.)

Shell echo-sed quine:

echo sed -eh -es/[\\$$\\\\\\\\\\$$\\\&\\\|]/\\\\\\\\\\\&/g -es/^/echo\\ / -es/$/\\\|/ -eG| sed -eh -es/[$$\\\\$$\&\|]/\\\\\&/g -es/^/echo\ / -es/$/\|/ -eG


I wanted to write a sed quine, but sed can only work on its input stream, not generate output spontaneously, so this is an echo-sed quine. This 154-character quine uses command-line sed, which automatically makes it hard to read, and uses three different sed commands, as well as two sequences of eleven backslashes in a row. This quine works in bash, ksh, and sh, but not csh or tcsh.

EDIT:

A blatant, and amusing, cheat: echo $BASH_COMMAND Another, unreasonably silly, cheat: export PROMPT_COMMAND='echo$BASH_COMMAND';$PROMPT_COMMAND C, 77 chars Maybe the easiest one in C. main(){char*c="main(){char*c=%c%s%c;printf(c,34,c,34);}";printf(c,34,c,34);}  34 is the ASCII decimal for ". • I count 76 bytes. – Lynn Jan 18 '17 at 15:06 • @Lynn He must have used wc and forgot to exclude the trailing newline :P – MD XF May 26 '17 at 16:32 # QBasic, 76 (110) 54 (72) Tested with QB64 on Windows 7, with auto-formatting turned off. READ a$:?a$;:WRITE a$:DATA"READ a$:?a$;:WRITE a$:DATA"  : is a statement separator, and ? is a shortcut for PRINT. The main trick here is using DATA and READ so we don't have to split the string up to add the quotes. Edit: I learned this week about the WRITE command, which outputs strings wrapped in double-quotes--a significant byte-saver here! Since actual QBasic doesn't let you turn off auto-formatting, here's the same thing with proper formatting in 72 bytes: READ x$: PRINT x$;: WRITE x$: DATA "READ x$: PRINT x$;: WRITE x$: DATA "  Original versions (76 bytes golfed, 110 formatted): READ a$:q$=CHR$(34):?a$+q$+a$+q$:DATA"READ a$:q$=CHR$(34):?a$+q$+a$+q$:DATA"  or READ a$: q$= CHR$(34): PRINT a$+ q$ + a$+ q$: DATA "READ a$: q$ = CHR$(34): PRINT a$ + q$+ a$ + q$: DATA "  • Note that this doesn't work with QBasic 1.1 for MS-DOS 6.2: the autoformatter can't be turned off. – Mark Feb 27 '15 at 7:58 • @Mark Good point. I added a formatted version. – DLosc Feb 28 '15 at 22:21 • You can just load the non-formatted file directly though, right? This seems like a limitation of the editor rather than the language itself. – 12Me21 Apr 2 '18 at 14:54 # RProgN, 3 bytes 0 0  Try it online! This exploits a potential flaw in our definition of proper quine: It must be possible to identify a section of the program which encodes a different part of the program. ("Different" meaning that the two parts appear in different positions.) Furthermore, a quine must not access its own source, directly or indirectly. The stack of RProgN is printed backwards, so the first 0 encodes the second 0, and vice versa. This can be verified empirically; the program 1 2  prints 2 1  Try it online! • Oh my, it's actually getting usage. I feel like a proud father. – ATaco Dec 16 '16 at 5:26 # √ å ı ¥ ® Ï Ø ¿ , 9 (possibly 11) bytes Non-competing as language post-dates the challenge 79 87 OW  Notice the double space between the 87 and the OW. This is necessary because of the way √ å ı ¥ ® Ï Ø ¿ outputs. The O command outputs the whole of the stack as numbers The W command outputs the whole stack as Unicode interpretations of the numbers ### The 11 byte solution The above code will output ===== OUTPUT ===== 79 87 OW ================== -----Program Execution Information----- Code : 79 87 OW Inputs : [] Stack : (79,87) G-Variable : None Byte Length : 9 Exit Status : 0 Error : None ---------------------------------------  This is obviously not the code inputted but is outputted automatically by the interpreter. If this is disallowed, there is an 11 byte solution that only outputs the required output: ł 79 87 OW  This will only output ł 79 87 OW  I'm not sure if the 9 byte answer is acceptable, could someone please tell me in the comments? • This is a much less trivial quine than usual - nice! – isaacg Mar 20 '17 at 4:46 • That looks valid (9 byte). I mean the other stuff is just interpreter items that are always there – Christopher May 21 '17 at 12:29 • this isn't non-competing because this is a catalogue and any language is fine – Destructible Lemon May 21 '17 at 23:17 • @DestructibleLemon I'm a stickler to explicit rules and it doesn't say that in the question. It's fine though. – caird coinheringaahing May 22 '17 at 6:10 • Gesundheit! Wait... that's a language name? You didn't just sneeze bytes? How do you say that language name in a conversation haha! – Magic Octopus Urn Sep 6 '18 at 16:18 # Reflections, 4222 bytes Since wastl out-golfed me by about... 1.810371 bytes through a vastly superior encoding system, I've decided to have another look at the problem. Since my program is still quite long, here's the main section (with SOHs replaced with spaces): \0=0#_(4:(2(4(40\ /# 0v\/(1v/ \+#@~ > ~< /#@#_#_#_1^1/ + \#1)(2:2)4=/  Try It Online! (but have patience) (ASCII-only points out that unchecking the time between steps will make it go faster, but beware of the javascript freezing up your browser) This uses the same encoding as wastl's answer, where each character with byte value n is represented by n newlines followed by + #  and the first character of the code is \ to change the pointer's direction down. Additionally, it also encodes the \ as well as the #,+ and newline in this process to save on doing them later The main code is a more streamlined version of wastl's, where quite a few shortcuts have been made. I've also replaced all the spaces with SOHs (byte value 1) to save on bytes. ### Detailed explanation \0=0 Create a copy of the data in stack 0 #_ Print the \ (4:(2(4(4 Push the +, \n, # to stack 4, and a copy of the newline to stack 2 0\ Switch back to the intact copy of the data /(1v/ Reverse the data > ~< ^1/ v\ ~ While the stack exists ^ v\ 1 Move data to stack 1 4=/ Copy #, \n, + (2:2) Copy newline \#1) Get top of data + \# Redefine origin and move up / + Push -2 /#@ Print the newline the value of the top of data times #_#_#_ Print the +, \n, # 1^ Switch back to the data and loop again /# 0v When the data stack is empty \+#@~ /#@#_#_#_1^ 0 Switch to the other copy of the data /# Redefine the origin to push 1 \+ #@ Print the whole stack ~ > And end  • You should also say that unchecking the time between steps box shortens run time to like <5 seconds – ASCII-only May 22 '18 at 0:58 • @ASCII-only Ehh, depends on the computer I guess. Mine freezes up and finishes in about 40 seconds – Jo King May 22 '18 at 1:51 # J (REPL) - 20 (16?) char Seems we're missing a J entry. Trivially, any sentence that doesn't evaluate gets itself printed in the REPL, so 1 or + or +/ % # are all quines in that sense. A non-trivial quine would be one that produces specifically a string containing the source code. ',~@,~u:39',~@,~u:39  u:39 is the ASCII character 39, i.e. the single quote, and ',~@,~u:39' is a string. , is the append verb. The main verb ,~@,~ evaluates as follows: x ,~@,~ y y ,~@, x NB. x f~ y => y f x "Passive" ,~ (y , x) NB. x f@g y => f (x g y) "At" (y,x) , (y,x) NB. f~ y => y f y "Reflex"  So the result is 'string'string when x is string and y is the single quote, and thus this is a quine when x is ,~@,~u:39. If we're allowed the J standard library as well, then we can write the 16 character (,quote)'(,quote)'  which appends the quote of the string (,quote) to itself. # JavaScript REPL, 21 bytes (_=$=>(_=${_})())()  It technically doesn't read its own file. … kind of seems like 0 is also a quine for JavaScript the way this is evaluated, though. • It reads its own source, though. – Joey May 12 '11 at 21:15 •  Uncaught SyntaxError: Unexpected token => in Chrome – Nakilon Jan 14 '15 at 9:36 • @Nakilon: Use Firefox. – Ry- Jan 14 '15 at 16:17 • +1 for the +_+ in the shorter version – user48538 Jan 4 '16 at 18:31 • Umm... the first one is actually HTML5. – Erik the Outgolfer Jun 15 '16 at 8:07 # TECO, 20 bytes <Tab>V27:^TJDV<Esc>V27:^TJDV  The <Esc> should be replaced with ASCII 0x1B, and the <Tab> with 0x09. • <Tab>V27:^TJDV<Esc> inserts the text <Tab>V27:^TJDV. This is not because there is a text insertion mode which TECO starts in by default. Instead, <Tab> text <Esc> is a special insertion command which inserts a tab, and then the text. A string whose own initial delimiter is part of the text -- very handy. • V prints the current line. • 27:^T prints the character with ASCII code 27 without the usual conversion to a printable representation. • J jumps to the beginning of the text. • D deletes the first character (the tab). • V prints the line again. ## T-SQL 24 This statment reproduces itself in the EVENTINFO column of the output: dbcc inputbuffer(@@spid)  Explanation: • dbcc inputbuffer() - Displays the last statement sent from the client with the specified process id to the current instance of Microsoft SQL Server • @@spid - Retrieves the current process id tested with SQL Server 2008 R2 and 2012; probably working with other versions as well Online demo: http://www.sqlfiddle.com/#!3/d41d8/2230 # APL, 22 bytes 1⌽22⍴11⍴'''1⌽22⍴11⍴'''  This is part of the FinnAPL Idiom Library.  '''1⌽22⍴11⍴''' ⍝ The string literal '1⌽22⍴11⍴' (quotes in string) 11⍴ ⍝ Fill an 11-element array with these characters ⍝ But the string has length 10, so we get '1⌽22⍴11⍴'' 22⍴ ⍝ Do this again for 22 chars: '1⌽22⍴11⍴'''1⌽22⍴11⍴'' 1⌽ ⍝ Rotate left (puts quote at the back)  Try it on ngn/apl # RETURN, 18 bytes "34¤¤,,,,"34¤¤,,,,  Try it here. First RETURN program on PPCG ever! RETURN is a language that tries to improve DUP by using nested stacks. # Explanation "34¤¤,,,," Push this string to the stack 34 Push charcode of " to the stack ¤¤ Duplicate top 2 items ,,,, Output all 4 stack items from top to bottom  # Factor - 74 69 65 bytes Works on the listener (REPL): USE: formatting [ "USE: formatting %u dup call" printf ] dup call  This is my first ever quine, I'm sure there must be a shorter one! Already shorter. Now I'm no longer sure... (bad pun attempt) What it does is: • USE: formatting import the formatting vocabulary to use printf • [ "U... printf ] create a quotation (or lambda, or block) on the top of the stack • dup call duplicate it, and call it The quotation takes the top of the stack and embeds it into the string as a literal. Thanks, cat! -> shaved 2 4 more bytes :D • Welcome to the site. This is a really good answer; however most people replace their old code with the new code and use the edit history to see the old code. You have, however, included a code breakdown and explanation, which not many people do on their first answer, so for that: +1. – wizzwizz4 Feb 14 '16 at 9:03 • @wizzwizz4 Thanks for the advice and up! Actually my 2nd answer, but first quine ever and first edit on PCG. – fede s. Feb 14 '16 at 22:07 • Well, if you ever need help, feel free to ping me. – wizzwizz4 Feb 14 '16 at 22:11 • I never realised a quine was so simple in Factor! Also, the bottom, shorter one can be a single line for 65 bytes, because you don't need the trailing newline: USE: formatting [ "USE: formatting %u dup call" printf ] dup call – cat May 17 '16 at 22:55 • Thanks, @cat Just assumed it expected EOL, but this makes more sense actually! – fede s. May 17 '16 at 23:07 # F#, 90 bytes let q="let q=%A printf(Printf.TextWriterFormat<_>q)q" printf(Printf.TextWriterFormat<_>q)q  F#’s smart printf comes back to byte us! We can’t write let q="...";;printf q q, as the first parameter to printf isn’t actually a string: printf : TextWriterFormat<'T> -> 'T  F# uses some compiler magic under the hood to guarantee type-safe printf calls. For example, "yay %d wow!" is a valid TextWriterFormat<int -> unit> literal, but not a valid TextWriterFormat<double -> unit> literal. But if we define the format string separately, the compiler will see it as a regular old string and complain. Instead, we have to convert q ourselves in the first argument. What about let q:TextWriterFormat<_>="..."? First of all, that’s two bytes longer. But second of all, the second argument to printf really needs to be a string, otherwise the typechecker will infer that we’re formatting a formatter, which in turn formats a formatter, which formats a… error FS0001: Type mismatch. Expecting a 'a but given a Printf.TextWriterFormat<('a -> unit)> The resulting type would be infinite when unifying ''a' and 'Printf.TextWriterFormat<('a -> unit)>'  Yep, an infinite type. Oops. • +1 for emoticon in the code <_> – user48538 Aug 3 '16 at 18:32 # S.I.L.O.S, 2642 2593 bytes Credits to Rohan Jhunjhunwala for the algorithm. A = 99 set A 112 A + 1 set A 114 A + 1 set A 105 A + 1 set A 110 A + 1 set A 116 A + 1 set A 76 A + 1 set A 105 A + 1 set A 110 A + 1 set A 101 A + 1 set A 32 A + 1 set A 65 A + 1 set A 32 A + 1 set A 61 A + 1 set A 32 A + 1 set A 57 A + 1 set A 57 A + 1 set A 10 A + 1 set A 67 A + 1 set A 32 A + 1 set A 61 A + 1 set A 32 A + 1 set A 57 A + 1 set A 57 A + 1 set A 10 A + 1 set A 66 A + 1 set A 32 A + 1 set A 61 A + 1 set A 32 A + 1 set A 103 A + 1 set A 101 A + 1 set A 116 A + 1 set A 32 A + 1 set A 67 A + 1 set A 10 A + 1 set A 108 A + 1 set A 98 A + 1 set A 108 A + 1 set A 68 A + 1 set A 10 A + 1 set A 67 A + 1 set A 32 A + 1 set A 43 A + 1 set A 32 A + 1 set A 49 A + 1 set A 10 A + 1 set A 112 A + 1 set A 114 A + 1 set A 105 A + 1 set A 110 A + 1 set A 116 A + 1 set A 32 A + 1 set A 115 A + 1 set A 101 A + 1 set A 116 A + 1 set A 32 A + 1 set A 65 A + 1 set A 32 A + 1 set A 10 A + 1 set A 112 A + 1 set A 114 A + 1 set A 105 A + 1 set A 110 A + 1 set A 116 A + 1 set A 73 A + 1 set A 110 A + 1 set A 116 A + 1 set A 32 A + 1 set A 66 A + 1 set A 10 A + 1 set A 112 A + 1 set A 114 A + 1 set A 105 A + 1 set A 110 A + 1 set A 116 A + 1 set A 76 A + 1 set A 105 A + 1 set A 110 A + 1 set A 101 A + 1 set A 32 A + 1 set A 65 A + 1 set A 32 A + 1 set A 43 A + 1 set A 32 A + 1 set A 49 A + 1 set A 10 A + 1 set A 66 A + 1 set A 32 A + 1 set A 61 A + 1 set A 32 A + 1 set A 103 A + 1 set A 101 A + 1 set A 116 A + 1 set A 32 A + 1 set A 67 A + 1 set A 10 A + 1 set A 105 A + 1 set A 102 A + 1 set A 32 A + 1 set A 66 A + 1 set A 32 A + 1 set A 68 A + 1 set A 10 A + 1 set A 70 A + 1 set A 32 A + 1 set A 61 A + 1 set A 32 A + 1 set A 57 A + 1 set A 57 A + 1 set A 10 A + 1 set A 69 A + 1 set A 32 A + 1 set A 61 A + 1 set A 32 A + 1 set A 103 A + 1 set A 101 A + 1 set A 116 A + 1 set A 32 A + 1 set A 70 A + 1 set A 10 A + 1 set A 108 A + 1 set A 98 A + 1 set A 108 A + 1 set A 71 A + 1 set A 10 A + 1 set A 70 A + 1 set A 32 A + 1 set A 43 A + 1 set A 32 A + 1 set A 49 A + 1 set A 10 A + 1 set A 112 A + 1 set A 114 A + 1 set A 105 A + 1 set A 110 A + 1 set A 116 A + 1 set A 67 A + 1 set A 104 A + 1 set A 97 A + 1 set A 114 A + 1 set A 32 A + 1 set A 69 A + 1 set A 10 A + 1 set A 69 A + 1 set A 32 A + 1 set A 61 A + 1 set A 32 A + 1 set A 103 A + 1 set A 101 A + 1 set A 116 A + 1 set A 32 A + 1 set A 70 A + 1 set A 10 A + 1 set A 105 A + 1 set A 102 A + 1 set A 32 A + 1 set A 69 A + 1 set A 32 A + 1 set A 71 A + 1 printLine A = 99 C = 99 B = get C lblD C + 1 print set A printInt B printLine A + 1 B = get C if B D F = 99 E = get F lblG F + 1 printChar E E = get F if E G  Try it online! • Good job! May I "borrow this post for my github repository? – Rohan Jhunjhunwala Aug 26 '16 at 19:12 • @RohanJhunjhunwala Sure. – Leaky Nun Aug 26 '16 at 19:18 # S.I.L.O.S, 3057 bytes A = 99 def S set S A 112 A + 1 S A 114 A + 1 S A 105 A + 1 S A 110 A + 1 S A 116 A + 1 S A 76 A + 1 S A 105 A + 1 S A 110 A + 1 S A 101 A + 1 S A 32 A + 1 S A 65 A + 1 S A 32 A + 1 S A 61 A + 1 S A 32 A + 1 S A 57 A + 1 S A 57 A + 1 S A 10 A + 1 S A 72 A + 1 S A 32 A + 1 S A 61 A + 1 S A 32 A + 1 S A 56 A + 1 S A 51 A + 1 S A 10 A + 1 S A 112 A + 1 S A 114 A + 1 S A 105 A + 1 S A 110 A + 1 S A 116 A + 1 S A 32 A + 1 S A 100 A + 1 S A 101 A + 1 S A 102 A + 1 S A 32 A + 1 S A 10 A + 1 S A 112 A + 1 S A 114 A + 1 S A 105 A + 1 S A 110 A + 1 S A 116 A + 1 S A 67 A + 1 S A 104 A + 1 S A 97 A + 1 S A 114 A + 1 S A 32 A + 1 S A 72 A + 1 S A 10 A + 1 S A 112 A + 1 S A 114 A + 1 S A 105 A + 1 S A 110 A + 1 S A 116 A + 1 S A 76 A + 1 S A 105 A + 1 S A 110 A + 1 S A 101 A + 1 S A 32 A + 1 S A 32 A + 1 S A 83 A + 1 S A 32 A + 1 S A 10 A + 1 S A 67 A + 1 S A 32 A + 1 S A 61 A + 1 S A 32 A + 1 S A 57 A + 1 S A 57 A + 1 S A 10 A + 1 S A 66 A + 1 S A 32 A + 1 S A 61 A + 1 S A 32 A + 1 S A 103 A + 1 S A 101 A + 1 S A 116 A + 1 S A 32 A + 1 S A 67 A + 1 S A 10 A + 1 S A 108 A + 1 S A 98 A + 1 S A 108 A + 1 S A 68 A + 1 S A 10 A + 1 S A 67 A + 1 S A 32 A + 1 S A 43 A + 1 S A 32 A + 1 S A 49 A + 1 S A 10 A + 1 S A 112 A + 1 S A 114 A + 1 S A 105 A + 1 S A 110 A + 1 S A 116 A + 1 S A 67 A + 1 S A 104 A + 1 S A 97 A + 1 S A 114 A + 1 S A 32 A + 1 S A 72 A + 1 S A 10 A + 1 S A 112 A + 1 S A 114 A + 1 S A 105 A + 1 S A 110 A + 1 S A 116 A + 1 S A 32 A + 1 S A 32 A + 1 S A 65 A + 1 S A 32 A + 1 S A 10 A + 1 S A 112 A + 1 S A 114 A + 1 S A 105 A + 1 S A 110 A + 1 S A 116 A + 1 S A 73 A + 1 S A 110 A + 1 S A 116 A + 1 S A 32 A + 1 S A 66 A + 1 S A 10 A + 1 S A 112 A + 1 S A 114 A + 1 S A 105 A + 1 S A 110 A + 1 S A 116 A + 1 S A 76 A + 1 S A 105 A + 1 S A 110 A + 1 S A 101 A + 1 S A 32 A + 1 S A 65 A + 1 S A 32 A + 1 S A 43 A + 1 S A 32 A + 1 S A 49 A + 1 S A 10 A + 1 S A 66 A + 1 S A 32 A + 1 S A 61 A + 1 S A 32 A + 1 S A 103 A + 1 S A 101 A + 1 S A 116 A + 1 S A 32 A + 1 S A 67 A + 1 S A 10 A + 1 S A 105 A + 1 S A 102 A + 1 S A 32 A + 1 S A 66 A + 1 S A 32 A + 1 S A 68 A + 1 S A 10 A + 1 S A 70 A + 1 S A 32 A + 1 S A 61 A + 1 S A 32 A + 1 S A 57 A + 1 S A 57 A + 1 S A 10 A + 1 S A 69 A + 1 S A 32 A + 1 S A 61 A + 1 S A 32 A + 1 S A 103 A + 1 S A 101 A + 1 S A 116 A + 1 S A 32 A + 1 S A 70 A + 1 S A 10 A + 1 S A 108 A + 1 S A 98 A + 1 S A 108 A + 1 S A 71 A + 1 S A 10 A + 1 S A 70 A + 1 S A 32 A + 1 S A 43 A + 1 S A 32 A + 1 S A 49 A + 1 S A 10 A + 1 S A 112 A + 1 S A 114 A + 1 S A 105 A + 1 S A 110 A + 1 S A 116 A + 1 S A 67 A + 1 S A 104 A + 1 S A 97 A + 1 S A 114 A + 1 S A 32 A + 1 S A 69 A + 1 S A 10 A + 1 S A 69 A + 1 S A 32 A + 1 S A 61 A + 1 S A 32 A + 1 S A 103 A + 1 S A 101 A + 1 S A 116 A + 1 S A 32 A + 1 S A 70 A + 1 S A 10 A + 1 S A 105 A + 1 S A 102 A + 1 S A 32 A + 1 S A 69 A + 1 S A 32 A + 1 S A 71 A + 1 printLine A = 99 H = 83 print def printChar H printLine S C = 99 B = get C lblD C + 1 printChar H print A printInt B printLine A + 1 B = get C if B D F = 99 E = get F lblG F + 1 printChar E E = get F if E G  Try it online! I am ashamed to say this took me a while to write even though most of it was generated by another java program. Thanks to @MartinEnder for helping me out. This is the first quine I have ever written. Credits go to Leaky Nun for most of the code. I "borrowed his code" which was originally inspired by mine. My answer is similar to his, except it shows the "power" of the preprocessor. Hopefully this approach can be used to golf of bytes if done correctly. The goal was to prevent rewriting the word "set" 100's of times. Please check out his much shorter answer! • How does this work? – Leaky Nun Aug 26 '16 at 18:44 • It's borked from my understanding @LeakyNun but it essentially writes it source code to the memory buffer, and then prints out commands to write itself to the memory buffer, and then writes itself out – Rohan Jhunjhunwala Aug 26 '16 at 18:46 • From my point of view this is not a quine? – Leaky Nun Aug 26 '16 at 18:55 • @LeakyNun it's borked... let me fix... should I delete, fix and undelete? – Rohan Jhunjhunwala Aug 26 '16 at 18:58 # Charcoal, 6431 32 (because of newlines) My first answer in charcoal ever! Similar to /// and other languages, just straight up ascii would print itself. however that is not payload and also boring, so here is an actual quine. taking a golfing tip from Ascii-only, and my realisation that the second looping is pointless, I have reduced by >50% Ａ´α´´´Ａ´Ｆ´α´⁺´´´´´ι´αα´ＡＦα⁺´´ια  Try it online! # Explanation (thanks to ascii-only for making most of this.) Ａ α Assign to a ´α´´´Ａ´Ｆ´α´⁺´´´´´ι´α "α´ＡＦα⁺´´ια", but with ´ escape character with each character these are the variable being assigned to, and the rest of the program that is not the string. ´Ａ Print Ａ to the grid. current grid: "Ａ" Ｆα⁺´´ι For each character in a, print ´ + character this results in the escaped version of the string which is the literal string that is assigned at the start. current grid state: "Ａ´α´´´Ａ´Ｆ´α´⁺´´´´´ι´α" α Print a ("α´ＡＦα⁺´´ια"), which is the commands after the string assignment. final grid state vvv: "Ａ´α´´´Ａ´Ｆ´α´⁺´´´´´ι´αα´ＡＦα⁺´´ια" [implicitly print the grid: "Ａ´α´´´Ａ´Ｆ´α´⁺´´´´´ι´αα´ＡＦα⁺´´ια", the source, with a trailing newline]  • Wish I was better at reading Charcoal. Looking forward to that explanation :) – Emigna May 19 '17 at 10:11 • I can hardly read this myself :P – Destructible Lemon May 19 '17 at 10:12 • You can leave off the final closing double angle bracket, saving 3 bytes: Ａ´α´´´Ａ´Ｆ´Ｌ´α´«´´´´´§´α´ι´»´Ｆ´Ｌ´α´«´§´α´ια´ＡＦＬα«´´§αι»ＦＬα«§αι – ASCII-only May 19 '17 at 10:33 • Oh wait you can also iterate over the string directly. 37 bytes: Ａ´α´´´Ａ´Ｆ´α´⁺´´´´´ι´Ｆ´α´ια´ＡＦα⁺´´ιＦαι – ASCII-only May 19 '17 at 10:38 • @ASCII-only couldn't this be one byte? f – Christopher May 19 '17 at 14:11 # ///, 204 bytes /<\>/<\\\\>\\\\\\//P1/<>/<<>\><>/<<>\<>\<>\<>\><>\<>\<>\<>\<>\<>\<>/<>/P<>1<>/P<>2<>/<>/P<<>\<>\><>\<>\<>2<>/P<>1<>/<>/<<>\><>/<<<>\<>\>><>\<>\<>/<>/<<>\<>\><>/<>/P<>1//P<\\>\\2/P1//<\>/<<\\>>\\//<\\>//P1  Try it online! With some helpful whitespace inserted: /<\>/<\\\\>\\\\\\/ /P1/ <>/<<>\><>/<<>\<>\<>\<>\><>\<>\<>\<>\<>\<>\<>/<>/P<>1<>/P<>2<>/<>/P<<>\<>\><>\<>\<>2<>/P<>1<>/<>/<<>\><>/<<<>\<>\>><>\<>\<>/<>/<<>\<>\><>/<>/P<>1 / /P<\\>\\2/P1/ /<\>/<<\\>>\\/ /<\\>// P1  # How it works • The long third line is the quining data. It is made from the entire rest of the program, with a P2 in the spot where the data itself would fit, and then with the string <> inserted before each character from the set \/12. • It would be harmless to put <> before all characters in the data, but only these are necessary - \/ because they need escaping to be copied, and 12 because it's vital to have a break inside P1 and P2 to prevent infinite loops when substituting them. • The first substitution changes all the <> prefixes into <\\>\\\. The \ in the source <\> is there to prevent its final printable form from being garbled by the other substitutions. • The second substitution includes the quining data, copying them to the other P1s in the program. The <\\>\\\ prefixes now become <\>\ in both copies. • The third substitution copies one of the quining data copies (in the substitution itself) into the middle of the other (at the end of the program), marked by the string P<\>\2. In the inner copy, the <\>\ prefix now becomes <> again. • The fourth substitution changes the inner copy's <> prefixes into <<\>>\. The change is needed to introduce the final backspace, protecting any following \s and /s that are to be printed. The inner <\> is necessary to prevent this substitution from infinitely looping – just a backslash here wouldn't do, as it would be garbled by the fifth substitution. • The fifth substitution removes all instances of the string <\>, both those remaining in the outer copy of the quining data, and those produced by the fourth substitution. • Finally, we reach the constructed copy of the program, with suitable backslashes prepended to some characters, ready for printing. # JavaScript (Firefox), 44 40 bytes eval(e="alert('eval(e='+uneval(e)+')')")  Not sure how I haven't thought of this before; it's basically exactly the same as the standard function quine (f=_=>alert('f='+f+';f()'))(), but with a string. Funnily enough, I only thought of this while attempting to demonstrate how similar string-based quines are to function-based quines... A cross-browser version (avoiding uneval) is 72 bytes: Q='"';q="'";eval(e="alert('Q='+q+Q+q+';q='+Q+q+Q+';eval(e='+Q+e+Q+')')")  Or ES6, 50 bytes: Q='"';eval(e="alert(Q='${Q}';eval(e=${Q+e+Q}))")  ### Previous answer, 74 bytes ".replace(/.+/,x=>alert(uneval(x)+x))".replace(/.+/,x=>alert(uneval(x)+x))  Simply takes the whole string and prepends its unevaluated form. Note: uneval may not work in all browsers. Here's a cross-browser version at 113 bytes: ".replace(/.+/,x=>alert(q+x+q+x.replace(/\\d/g,q)),q='1')".replace(/.+/,x=>alert(q+x+q+x.replace(/\d/g,q)),q='"')  ### Original answer, 118 bytes Now, this certainly isn't a winner, but AFAIK, this is the first ever non-source-reading quine in JS! :D alert([A=",A,A].join(String.fromCharCode(34)).slice(49,-9))alert([A=",A,A].join(String.fromCharCode(34)).slice(49,-9))  How does it work, you ask? Well, if you look closely, you will see that it's really the same thing repeated twice: alert([A=",A,A].join(String.fromCharCode(34)).slice(49,-9))  The logic here is to A) place a copy of the real code in a string, and B) orient this string so the program can be split into two identical halves. But how could we get those quotes in there? Well, we could either navigate an insanely difficult path of inserting backslashes before a quote, or use the (painfully long) workaround String.fromCharCode(34) to retrieve one. The latter method is what I chose. So, this code puts three copies of the string ,A,A].join(String.fromCharCode(34)).slice(49,-9))alert([A=  in an array, then joins them with quotes (using the mentioned workaround): ,A,A].join(String.fromCharCode(34)).slice(49,-9))alert([A=",A,A].join(String.fromCharCode(34)).slice(49,-9))alert([A=",A,A].join(String.fromCharCode(34)).slice(49,-9))alert([A=  and finally, slices off the unnecessary characters from the beginning and end: ,A,A].join(String.fromCharCode(34)).slice(49,-9))alert([A=",A,A].join(String.fromCharCode(34)).slice(49,-9))alert([A=",A,A].join(String.fromCharCode(34)).slice(49,-9))alert([A= alert([A=",A,A].join(String.fromCharCode(34)).slice(49,-9))alert([A=",A,A].join(String.fromCharCode(34)).slice(49,-9)) This leaves us with the text of the original program, which is alerted to the user. If the alert is unnecessary, here's a 104-byte alternative: [A=",A,A].join(String.fromCharCode(34)).slice(48,-3)[A=",A,A].join(String.fromCharCode(34)).slice(48,-3)  # 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 Otherwise return to the space printing loop \ 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. – Nit 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 (() <>((({}())[()]))<> >}{} # Add 1 to -n ()) # If n was not 1: ((){[()]< # Add 1 to 1-n (({}())< # 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 (({}<{{}}>{}) (< # Add 1 if n was 2; add 2 otherwise # 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 # 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  # 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. – YoYoYonnY 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