[Question]
  [
# Introduction
A quine is a program that outputs its own source code. For example, a well-known Python quine is `_='_=%r;print(end=_%%_)';print(end=_%_)`. Running it outputs `_='_=%r;print(end=_%%_)';print(end=_%_)`, therefore it is a valid quine. An error quine is similar to a regular quine, however it must output to STDERR. In Python (for example), this could be achieved by replacing both instances of `print` in the above code with `exit`. A polyglot is a program that is valid in multiple languages.
# Challenge
Write two **full programs** in two programming languages of your choice. The first one should be a quine, and the second an error quine. When concatenated (in any order, you can pick), it should form a Hello, World! program in a third programming language.
# Example
Say you have a language `A`\* in which a valid quine is `123`, and another language `B`\* where `abc` is an error quine. Then, `123abc` (or `abc123`) should be a valid Hello, World! program in language `C`\*. If this is the case, your answer should look similar to the following:
---
# A, B, C, score 3
## A, 3 bytes - Quine
```
123
```
[Try it online!](https://tio.run "placeholder link")
## B, 3 bytes - Error quine
```
abc
```
[Try it online!](https://tio.run "placeholder link")
## C, 6 bytes - Hello, World!
```
123abc
```
[Try it online!](https://tio.run "placeholder link")
## Explanation (optional)
Lorem ipsum dolor sit amet, consectetur adipiscing elit. Phasellus sem mi, dignissim a odio vehicula, tincidunt ultrices tellus. Etiam luctus scelerisque urna, ac sodales nisl rhoncus at. Cras ac accumsan velit. Integer eget mi nec diam suscipit pretium a ac massa. Praesent at enim nec nisl molestie aliquet nec sed lorem. Duis iaculis condimentum dui at ullamcorper. Fusce molestie iaculis dolor. Cras vel metus dictum, aliquam quam sit amet, gravida tortor. Praesent maximus quam porttitor, vulputate magna eu, rhoncus nunc. Sed accumsan dui ut sapien semper finibus. Nulla eget dictum justo.
---
# Scoring
Your score is the arithmetic mean of the lengths of the two quines (i.e. half the length of the Hello, World! program).
# Rules
* All three programming languages used must be different.
* The Hello, World! program should output exactly `Hello, World!`. A trailing newline is allowed.
* [Standard loopholes](https://codegolf.meta.stackexchange.com/questions/1061/loopholes-that-are-forbidden-by-default) are forbidden, except for storing information in the file name; if done so in either one of the quines, it will add <length of file name> bytes to the length of both that program and the Hello, World! program, therefore adding half of <length of file name> to your score. If done in the Hello, World! program, it adds the same amount to your score and bytecount for it, but not for either one of your quines. Note that, if you're not doing this, the file name will be assumed to be `.code.tio` even if not running on TIO.
* The regular quine **must** output to STDOUT and the error quine **must** output to STDERR. If STDOUT and STDERR do not exist in your language(s), use the closest equivalent(s). However, the Hello, World! program may output using any of the [standard I/O methods](https://codegolf.meta.stackexchange.com/questions/2447/default-for-code-golf-input-output-methods). Also, the quine and Hello, World! programs may output anything to STDERR, and the error quine may output anything to STDOUT.
* If possible, please link to an online interpreter (e.g. [TIO](https://tio.run)) to run your program on.
* Please explain your answer. This is not necessary, but it makes it easier for others to understand.
* Neither one of the quines may output a trailing newline unless that newline also occurs in the source code.
* Languages newer than the question are allowed. This means you could create your own language where `a` is a quine, `b` is an error quine, and `ab` is Hello, World!, and post an answer in that language with score 1, but expect many downvotes.
* Non-programming languages are allowed. A non-programming language is a language which doesn't satisfy both of these conditions:
	+ Able to take two integers as input and print their sum
	+ Able to take one integer as input and print a truthy value if it is prime, and a falsy value if it is not
* Different versions of the same language may be used. For example, your quine could be in Python 2 and your Hello, World! program in Python 3.
* This is [code-golf](/questions/tagged/code-golf "show questions tagged 'code-golf'"), so shortest code in bytes wins!
\*Fun fact: these are all actual languages!
  
[Answer]
# C, Bash, C++, score 174.5 175
## C, 301 bytes - Quine
```
#include<stdio.h>
int main(){
#ifdef __cplusplus
printf("Hello, World!"
#else
char*c="#include<stdio.h>%cint main(){%c#ifdef __cplusplus%cprintf(%cHello, World!%c%c#else%cchar*c=%c%s%c;printf(c,10,10,10,34,34,10,10,34,c,34,10,10%c#endif%c);}//";printf(c,10,10,10,34,34,10,10,34,c,34,10,10
#endif
);}//
```
[Try it online!](https://tio.run/##lYzLCsIwEEX3@YqaEmilWqXuqq79A5el3CQ2ENPSx0r89phoKEpXwh2YGc492NwAa2NloCcujsPIVbttzkSZMbrXyiTpg8RKciGjqkKnp8EP6XoHyIRehNZtFl3bXvMVJbHQgyBo6n6NE11YGb60DEsvQxAz/JgZHO3dDEHuPo4uA45svwspDj7zjvnyBsOVZEjLZ57Tf7rkUyXvprUv)
## Bash, 48 49 bytes - Error quine
```
.code.tio: line 1: .code.tio:: command not found
```
[Try it online!](https://tio.run/##S0oszvj/Xy85PyVVryQz30ohJzMvVcHQSgEhZKWQnJ@bm5iXopCXX6KQll@al8L1/z8A) (the trailing newline was added, see comments)
## C++, 349 350 bytes - Hello, World!
```
#include<stdio.h>
int main(){
#ifdef __cplusplus
printf("Hello, World!"
#else
char*c="#include<stdio.h>%cint main(){%c#ifdef __cplusplus%cprintf(%cHello, World!%c%c#else%cchar*c=%c%s%c;printf(c,10,10,10,34,34,10,10,34,c,34,10,10%c#endif%c);}//";printf(c,10,10,10,34,34,10,10,34,c,34,10,10
#endif
);}//.code.tio: line 1: .code.tio:: command not found
```
[Try it online!](https://tio.run/##lYzLDoIwEEX3/YoR0kQMokRXoK79A5eE3LbSpLSEx8r47QhKfISVyUwyc3PuQVWtr0Df@9rCdEIemlZoFxUnpm1LZa7tMrgxXyshFWUZKtM147KqHgC19M7SGBfSxdVGLDzmS9NIhiKvVzh6MyvHl5Zj7uWYxBw/Zo6BHt0ck3xIBjqdcITxdprdfpz3jfc3GqzQiiNI75uN90@Xvars2YzghIxa7RIy2kqKE/pECcGVZW4FWdeScp0VrO8f)
---
# Explainations and notes
The **C** *quine* is inspired by [this](https://rosettacode.org/wiki/Quine#C) C quine (the short version), and contains C++ code for the *Hello, World!*.
The **Bash** *error quine* works due to the TIO implementation, but given that error messages are generally implementation defined, it might be hard to print them in some standard way (other than directly outputting to stderr, which is just like a *regular quine*... how unoriginal would that be). The submitted Bash program may be an invalid Bash program, but it is still a valid *error quine* in Bash. (Edit: note the trailing newline that is now legal to output.)
The **C++** *Hello, World!* doesn't output a trailing newline, but the challenge doesn't require it. After the preprocessor preprocessing, the only code source left is the `main` function with a simple `printf` call.
What was used in this answer are similarities between C and C++, very useful for polyglots (C is not *entirely* contained by C++, but it is contained enough) (for example: the usage of the C standard library is almost the same in these two languages which allows for a single `#include` directive, the `main` function definition is also similar enough to factorize the beginning and end out of the preprocessor-picked variations). The preprocessor and the `__cplusplus` macro are almost necessary at this point as they allow the C and C++ interpreters (or compilers, whatever) to pick only a specific subset of the program. The trailing line comment `//` ensures that the concatenation with a TIO Bash error doesn't upsets the C++ parser as it will completely ignore it.
I didn't find a way to to golf it even further. An other approach or a different set of languages are probably to be considered. For example, maybe using [Argh!](https://esolangs.org/wiki/Argh!) or INTERCAL for the *error quine* (or any other language in which error output is part of the language specification (these languages are rare, even among esolangs)). It might also be more interesting to use an other strategy than this """polyglot""" that makes each language ignore the code designed for the other languages instead of actually running most of the code.
[Answer]
# [MathGolf](https://github.com/maxbergmark/mathgolf/blob/master/math_golf.txt), [gnuplot](http://www.gnuplot.info/), [Underload](https://esolangs.org/wiki/Underload), score: 33.5
## [MathGolf](https://github.com/maxbergmark/mathgolf/blob/master/math_golf.txt), 9 [bytes](https://github.com/maxbergmark/mathgolf/blob/master/code_page.py) (Quine)
```
√ø'√ø\_'√ø\_
```
[Try it online.](https://tio.run/##y00syUjPz0n7///wfvXD@2PiwcT//wA)
## [gnuplot](http://www.gnuplot.info/), 58 bytes (Error quine)
```
(Hello, World!)S
^
".code.tio", line 2: invalid command
```
With one leading and two trailing newlines.
[Try it online.](https://tio.run/##S88rLcjJL/n/n0vDIzUnJ19HITy/KCdFUTOYK45LSS85PyVVryQzX0lHISczL1XByEohM68sMSczRSE5Pzc3MS@Fi@v/fwA)
## [Underload](https://esolangs.org/wiki/Underload), 67 bytes (Hello, World!)
```
√ø'√ø\_'√ø\_
(Hello, World!)S
^
".code.tio", line 2: invalid command
```
With two trailing newlines.
[Try it online.](https://tio.run/##K81LSS3KyU9M@f//8H71w/tj4sEEl4ZHak5Ovo5CeH5RToqiZjBXHJeSXnJ@SqpeSWa@ko5CTmZeqoKRlUJmXlliTmaKQnJ@bm5iXgoX1///AA)
### Explanation:
**MathGolf:**
```
√ø          # Push a string of four characters: 
 '√ø\_      #  "'√ø\_"
     '√ø    # Push character "√ø"
       \   # Swap the top two values on the stack
        _  # Duplicate the top value on the stack
           # (after which the entire stack joined together is output implicitly)
```
**gnuplot:**
I've never used gnuplot before, but I simply tried random languages on TIO that contains `(Hello, World!)S` for the Underload program, and result in an error quine at the same time, of which gnuplot was one of the few, and the shortest I could find.
It will ignore the leading newline, and then complain about the `(Hello, World!)S` being invalid on line 2. Everything after that is fortunately enough ignored.
**Underload:**
Underload will simply print everything between `(...)S`, which is the intended `Hello, World!` in this case. It does give an error due to the rest of the program, but we can ignore STDERR and only look at the STDOUT, which [is allowed by default](https://codegolf.meta.stackexchange.com/a/4781/52210).
[Answer]
# [Y](https://github.com/ConorOBrien-Foxx/Y), [nameless language](https://github.com/bforte/nameless-lang), [Deadfish~](https://github.com/TryItOnline/deadfish-), 4.5
## [Y](https://github.com/ConorOBrien-Foxx/Y), 3 bytes
```
Uwp
```
[Try it online](http://conorobrien-foxx.github.io/Y/): Copy-paste the code from above (or type it manually), and click on the 'timeout run' button.
## [nameless language](https://github.com/bforte/nameless-lang), 6 bytes
```
[[0]]
```
With trailing newline.
[Try it online.](https://tio.run/##y0vMTc1JLS7@/z862iA2luv/fwA)
## [Deadfish~](https://github.com/TryItOnline/deadfish-), 9 bytes
```
[[0]]
Uwp
```
[Try it online.](https://tio.run/##S0lNTEnLLM7Q/f8/OtogNpYrtLzg/38A)
### Explanation:
**Y:**
```
U    # Begin scanning, ignoring any links, and record as string once another `U` is
     # encountered, while starting the string itself with a leading "U"
 wp  # "wp"
U    # Wraps around to the start of the program again, finishing the string "Uwp"
 w   # No-op
  p  # Print the stack
```
I'm pretty sure Y is the language with the shortest [proper quine](https://codegolf.meta.stackexchange.com/questions/4877/what-counts-as-a-proper-quine) available, of just 2 bytes with `Up`.
**nameless language:**
nameless language is a brainfuck derivative using 0s and 1s in 4-bit parts for the builtins. It will also debug the pointers to STDERR by default, which starts with `[[0]]` for empty programs.
**Deadfish~:**
Basically every character we used in the Deadfish~ program is a no-op, except for the `w`, which is the builtin to print `Hello, World!` to STDOUT.
[Answer]
# [V (vim)](https://github.com/DJMcMayhem/V), [><>](https://esolangs.org/wiki/Fish), [Help, WarDoq!](https://esolangs.org/wiki/Help,_WarDoq!), score 16
## V, 6 bytes (Quine)
```
H2aH2a
```
[Try it online!](https://tio.run/##K/v/38MoEYj@//8PAA "V (vim) ‚Äì Try It Online")
```
H      # move cursor to first non-blank character (effectively no-op)
 2a    # twice append
   H2a # literal characters
```
---
## ><>, 26 bytes (Error quine)
```
something smells fishy...
```
[Try it online!](https://tio.run/##S8sszvj/vzg/N7UkIzMvXaE4NzUnp1ghDShcqaenx/X/PwA "><> ‚Äì Try It Online")
Note the trailing newline. Quoting from [Esolangs](https://esolangs.org/wiki/Fish):
> 
> Although there are multiple reasons an error may occur, there is only one error message: *something smells fishy...*
> 
> 
> 
---
## Help, WarDoq!, 32 bytes (*Hello, World!*)
```
H2aH2asomething smells fishy...
```
[Try it online!](https://tio.run/##S85KzP2fmmhgaxVYreSR4Zrqk@OfH14eVOSSoqPomBhQEFioFFgTDZRSUkrNyclXSoxW1/GJDU5UCi9XUsovykkBiSj6xMZa5WpZJURXF2UWZWrXgqk4EJVbACKrgFRgQmC4aoJPrHZqkVWdn1atlUfdfyDwMEoEouL83NSSjMy8dIXiXKA9xQppmcUZlXp6elwA "CJam ‚Äì Try It Online") Link is to an interpreter in CJam identical to the reference implementation described at [Esolangs](https://esolangs.org/wiki/Help,_WarDoq!). The code (without the trailing newline, due to technical limitations) can also be [run](http://cjam.aditsu.net/#code=l%3AQ%7B%22HhEeLlOoWwRrDd%2C!AaPpQq%22Q%7C%5B%22Hh%22%22ello%22a%5B%27%2CL%5DSa%22Ww%22%22orld%22a%5B%27!L%5D%5D%3Am*%3A%60%5B%7Briri%2B%7D%7Briri%5E%7D%7Brimp%7D%7Brizmp%7DQ%60Q%7B%5C%2B%7D*%60L%5D%2Ber%3A%7EN*%7D%3AH%7E&input=H2aH2asomething%20smells%20fishy...) from the CJam interpreter linked at Esolangs, but it unhelpfully combines STDOUT and STDERR into one output field.
```
H                               # print 'Hello, World!'
 2                              # ignored
  a                             # throws an error: attempts to read two integers from STDIN and XOR them
   H2asomething smells fishy... # (not executed)
```
[Answer]
# [Ruby](https://www.ruby-lang.org/), [><>](https://esolangs.org/wiki/Fish), [Stax](https://github.com/tomtheisen/stax), score = 48 43
## [Ruby](https://www.ruby-lang.org/), 60 bytes (quine)
```
"Hello, World!"
puts <<2*2,2
"Hello, World!"
puts <<2*2,2
2
```
[Try it online!](https://tio.run/##KypNqvz/X8kjNScnX0chPL8oJ0VRiaugtKRYwcbGSMtIx4gLr6QR1///AA "Ruby ‚Äì Try It Online")
## [><>](https://esolangs.org/wiki/Fish), 26 bytes (error quine)
```
something smells fishy...
```
[Try it online!](https://tio.run/##S8sszvj/vzg/N7UkIzMvXaE4NzUnp1ghDShcqaenx/X/PwA "><> ‚Äì Try It Online")
## [Stax](https://github.com/tomtheisen/stax), 86 bytes (hello world)
```
"Hello, World!"
puts <<2*2,2
"Hello, World!"
puts <<2*2,2
2
something smells fishy...
```
[Try it online!](https://tio.run/##Ky5JrPj/X8kjNScnX0chPL8oJ0VRiaugtKRYwcbGSMtIx4gLr6QRV3F@bmpJRmZeukJxLlBhsUJaZnFGpZ6eHtf//wA "Stax ‚Äì Try It Online")
*-5 score thanks to Dingus*
[Answer]
# Objective-C++/NASM/ARM Assembler, score ~~114.5~~ 115.5
## Objective-C++ (clang) `-fmodules`, quine, ~~188~~ 187 bytes
```
@import std;int main(){auto s="@import std;int main(){auto s=%c%s%1$c;printf(s,34,s,R%1$c(%3$s)%1$c,10);}%4$c";printf(s,34,s,R"(
.macro instruction x;.print"Hello, World!";.endm@)",10);}
```
Includes trailing newline.
I would post a link but unfortunately modules appear to be borked on both TIO and Wandbox.
When Travis decides to wake up, I will link a non-interactive demo.
You will see why I need Objective-C++ in a moment.
## NASM, error quine, ~~42~~ 44 bytes
```
t.:1: error: parser: instruction expected
```
Just your standard NASM error quine.
Requires the program to be named `t.`
The length depends on the filename, but nasm will only properly quine if the filename contains a dot and the first character isn't a dot.
[Try it online!](https://tio.run/##S0oszvifnFiiYKdQoqdgY6Pg6u/2v0TPytBKIbWoKL/ISqEgsag4FUhn5hWXFJUml2Tm5ymkVhSkJpekpnD9Byrn4spLLM4Fav8PAA)
## ARM Assembler (clang), Hello World, ~~230~~ 231 bytes
Uses the `.print` GAS directive.
```
@import std;int main(){auto s="@import std;int main(){auto s=%c%s%1$c;printf(s,34,s,R%1$c(%3$s)%1$c,10);}%4$c";printf(s,34,s,R"(
.macro instruction x;.print"Hello, World!";.endm@)",10);}
t.:1: error: parser: instruction expected
```
[Try it online!](https://tio.run/##fYw9a8QwEER7/wpF2GCDZGLuKouDK1OnSb0n7xmBPszuHhhC/nqUu6QJKVLNMO8x3voIea31HNJWSBTL4kIWlSDkfniHmxTFJ/0/7nzH3dR6t9EdXns2h6Nh8/rY@u7Q8vBoZnoe3Ed3bL3@K@q@GRN4KipkFrp5CSWr3Y3fnn7BGItRb4Xi8qTdiHlJ50H/HDYyztOskKjQrDYgxnv@/sF9Qy@4NLV@@muElau1ArSinICSzSWjRbiEandgxnSJSNX6Lw)
## Explanation
First, let's ungolf the Obj-C++ quine and remove the actual quine part to show what is going on:
```
@import std;
int main()
{
    auto fmt = "...";
    printf(fmt, '"', fmt, R"(...)", '\n');
}
```
So the ObjC++ quine is a fairly standard C++ quine, although it uses the Objective-C `@import` extension and a raw string literal. Other than that, there really isn't that much to explain.
You may ask, "why are you using `@import`? If you have modules, you can just do `import`".
The answer is that, in ARM assembly, `@` is a comment. And that is the magic (and literally the only reason we are using ObjC++).
So first, we make the ARM assembler completely ignore the first line *while also* `@import`ing `printf`.
I'd *love* to just use ObjC so I can have my implicit int, but `.print` requires a quoted string. I don't see any way to do this without raw string literals. üò≠
As for the assembly thing, I decided to use code from BOTH the NASM quine and the Obj-C++ quine, which I believe was the intended meaning of having the programs concatenated.
I could save a lot of bytes by just commenting out the NASM code though (it would go down to a score of 96, but I prefer this more creative solution.
For the assembler, I define a macro `instruction`:
```
.macro instruction x
    .print "Hello, World!"
.endm
```
Then, when I append the NASM quine, it is parsed as a bunch of labels followed by `instruction expected`:
```
.t:
1:
error:
parser:
        instruction  expected
```
which calls the `instruction` macro I just defined, executing the compile-time `.print "Hello, World!"` statement.
---
For the reference, here is the more boring one which comments out the NASM line.
# Objective-C++/NASM/ARM Assembler, boring version, score 96
## Objective-C++ (clang) `-fmodules`, quine, 149 bytes
Note: newline is no longer necessary.
```
@import std;int main(){auto s="@import std;int main(){auto s=%c%s%1$c;printf(s,34,s,R%1$c(%3$s)%1$c);}";printf(s,34,s,R"(
.print"Hello, World!"@)");}
```
## NASM, error quine, 44 bytes
```
t.:1: error: parser: instruction expected
```
Just like before, needs the filename to be `t.`.
## ARM Assembler (clang), Hello World, 192 bytes
```
@import std;int main(){auto s="@import std;int main(){auto s=%c%s%1$c;printf(s,34,s,R%1$c(%3$s)%1$c);}";printf(s,34,s,R"(
.print"Hello, World!"@)");}t.:1: error: parser: instruction expected
```
[Try it online!](https://tio.run/##fYoxC8IwEEZ3f0UMLbTQCEWnlkJHZxfnM72WQJqUuxME8a8bW0cHp@/jvWeN9RCmlHo3L5FEsQytC6JmcKEon3CXqLjT/3Vuc87rzLYLrXIsuDqeKq4uGyvyY8bl9sr2pX8LXewOX6TP6H2s1DWSH/a6L/Way6GpG4VEkRq1ADGu6wIL3a24GBQ@FrSCwy6ltx09TJyMEaAJpQOaTYgBDcLNJfMAZpxvHikZ@wE)
This version removes the trailing newline and just comments out the NASM error. The .print is directly run instead of requiring the macro.
However, the ARM program will still do the same thing without the NASM program. Therefore, I am (at least personally) going by the higher score because I feel it is more in the spirit of the challenge and not an ugly hack.
[Answer]
# [Perl 5](https://www.perl.org/), [PHP](https://php.net/), [Perl 4](https://www.perl.org/) Score 84
## [Perl 5](https://www.perl.org/), 75 bytes (Quine)
```
eval($s='printf(-1**2+1?"Hello, World!":"eval(\$s=%c%s%c);#",39,$s,39);');#
```
[Try it online!](https://tio.run/##K0gtyjH9/z@1LDFHQ6XYVr2gKDOvJE1D11BLy0jb0F7JIzUnJ19HITy/KCdFUclKCawwBqhSNVm1WDVZ01pZScfYUkelGEhqWqsD@f//AwA "Perl 5 ‚Äì Try It Online")
## [PHP](https://php.net/), 93 bytes (Error Quine)
```
PHP Parse error:  syntax error, unexpected 'Parse' (T_STRING) in Command line code on line 1
```
[Try it online!](https://tio.run/##K8go@P8/wCNAISCxqDhVIbWoKL/ISkGhuDKvJLECwtVRKM1LrShITS5JTVFQB6tTV9AIiQ8OCfL0c9dUyMxTcM7PzU3MS1HIycxLVUjOT0lVyM@DcAy5/v//l19QkpmfV/xft0iBplYBAA "PHP ‚Äì Try It Online")
## [Perl 4](https://www.perl.org/), 168 bytes (Hello World)
```
eval($s='printf(-1**2+1?"Hello, World!":"eval(\$s=%c%s%c);#",39,$s,39);');#PHP Parse error:  syntax error, unexpected 'Parse' (T_STRING) in Command line code on line 1
```
[Try it online!](https://tio.run/##JcpBC4IwGIDhe7/iaylTWwerS0p06JBdQkrwEsTYvkCYm2wW9uuX6OWFB94Ordp7j1@uosAdaWcb3b@jTZok23V6IgUqZRjUxiq5JBmZxud4hiJ0oYjzFWG7Awvc2Dino8uihJJbh4DWGpsBuJ/u@TCTwUfj0KHoUQKdPgpR9XpU9@vtEkOj4WzalmsJqtEIwkgEo2ekC@// "Perl 4 ‚Äì Try It Online")
## EXPLANATION:
**EDIT**: Due to OP's decision about PHP errors I had to resort to more traditional tricks, sorry. Welcome to the classical comment!
* the difference between the quine and HelloWorld is that in Perl 4 the minus operator takes precedence over exponentiation (`-1**2+1` will be 2 and then truthy), while the contrary in Perl 5 (`-1**2+1` will be 0 and then falsy)
* The error quine is nothing special, notice the trailing newline
* Nothing more for the third, uses a comment
[Answer]
# [Python 3](https://docs.python.org), [><>](https://esolangs.org/wiki/Fish), [Befunge-93](https://github.com/catseye/Befunge-93), score 54
## [Python 3](https://docs.python.org), 82 bytes - Quine
```
"!dlroW ,olleH">':#,_@';_='"!dlroW ,olleH">\':#,_@\';_=%r;print(_%%_)';print(_%_)
```
[Try it online!](https://tio.run/##K6gsycjPM/7/X0kxJacoP1xBJz8nJ9VDyU7dSlkn3kHdOt5WHV0qBiIXA5JULbIuKMrMK9GIV1WN11SHc@I1uf7/BwA "Python 3 ‚Äì Try It Online")
```
"!dlroW ,olleH">':#,_@';_='"!dlroW ,olleH">\':#,_@\';_=%r;print(_%%_)';print(_%_)  # full program
"!dlroW ,olleH">':#,_@';                                                           # singleton comparison statement (effectively NOP)
                        _=                                                         # set variable _ to...
                          '"!dlroW ,olleH">\':#,_@\';_=%r;print(_%%_)';            # literal
                                                                       print(_     # output _ with a trailing newline...
                                                                              %    # with the %r replaced by...
                                                                               _   # _'s value...
                                                                                   # including quotes...
                                                                              %    # and the %% replaced by %
                                                                                )  # end function call
```
## [><>](https://esolangs.org/wiki/Fish), 26 bytes - Error quine
```
something smells fishy...
```
[Try it online!](https://tio.run/##S8sszvj/vzg/N7UkIzMvXaE4NzUnp1ghDShcqaenx/X/PwA "><> ‚Äì Try It Online")
```
s...  # trimmed program
s     # invalid command, causes fatal error "something smells fishy...\n"
 ...  # unreachable code
```
## [Befunge-93](https://github.com/catseye/Befunge-93), 108 bytes - Hello, World!
```
"!dlroW ,olleH">':#,_@';_='"!dlroW ,olleH">\':#,_@\';_=%r;print(_%%_)';print(_%_)
something smells fishy...
```
[Try it online!](https://tio.run/##S0pNK81LT/3/X0kxJacoP1xBJz8nJ9VDyU7dSlkn3kHdOt5WHV0qBiIXA5JULbIuKMrMK9GIV1WN11SHc@I1uYrzc1NLMjLz0hWKc1NzcooV0jKLMyr19PS4/v8HAA "Befunge-93 ‚Äì Try It Online")
```
"!dlroW ,olleH">':#,_@...  # trimmed program
"                          # push charcodes of...
 !dlroW ,olleH             # literal...
"                          # separately onto stack
              "            # end literal
               >           # move right
                '          # NOP (unrecognized command)
                 :         # duplicate top of stack when going right, NOP when going left
                  #        # skip over next command in current direction
                   ,       # output top of stack as a character when going left, NOP when going right
                    _      # pop top of stack, go left if nonzero
                     @     # terminate
                      ...  # unreachable code
```
]